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

Comparar imágenes con la Vision API

Lección 10 de 12 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Análisis visual comparativo
  2. Comparación antes/después
  3. Control de calidad de productos
  4. Seguimiento de la evolución en el tiempo
  5. Comparación de interfaces de usuario
  6. Mejores prácticas para la comparación
  7. Puntos clave

Análisis visual comparativo

La comparación de imágenes es un caso de uso potente que aprovecha la capacidad de múltiples imágenes tratada en la Lección 6. La pregunta deja de ser «¿qué muestra esta imagen?» para convertirse en «¿qué ha cambiado?», una operación que un modelo semántico gestiona de forma fundamentalmente distinta a un comparador de píxeles. Mientras que una diferencia de píxeles indica una divergencia sin calificarla, el modelo puede afirmar que una etiqueta se ha desplazado dos milímetros y que un logotipo ha desaparecido, y luego juzgar cuál de los dos hechos es relevante.

Control de calidad, seguimiento de la evolución, detección de regresiones visuales: esta lección muestra cómo estructurar los prompts de comparación y aprovechar los resultados.

Comparación antes/después

El escenario más común consiste en verificar qué ha cambiado entre dos estados. El mensaje de sistema define el método de comparación, mientras que el mensaje de usuario identifica las imágenes:

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": """Eres un experto en análisis comparativo de imágenes. Cuando se te presenten dos imágenes:
1. Describe brevemente cada imagen
2. Enumera las diferencias identificadas (con su ubicación)
3. Evalúa la importancia de cada diferencia (menor/mayor)
4. Proporciona una puntuación global de similitud (0-100 %)"""
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Imagen ANTES (referencia):"},
                {"type": "image_url", "image_url": "https://exemple.com/avant.jpg"},
                {"type": "text", "text": "Imagen DESPUÉS (estado actual):"},
                {"type": "image_url", "image_url": "https://exemple.com/apres.jpg"},
                {"type": "text", "text": "Identifica todas las diferencias entre estas dos imágenes."}
            ]
        }
    ]
)

print(response.choices[0].message.content)

Intercalar texto («Imagen ANTES», «Imagen DESPUÉS») ayuda al modelo a identificar la función de cada imagen. El tercer paso del prompt de sistema es lo que hace que el informe sea ejecutable: sin priorización, recibirás una lista donde un cambio de sombra pesa lo mismo que una pieza faltante.

Control de calidad de productos

Al final de la cadena de producción, este informe debe leerlo un programa, no una persona. Por tanto, combinamos la comparación con el modo JSON de la Lección 9: el modelo devuelve un veredicto, una puntuación y una lista de defectos cualificados que el código puede explotar de inmediato.

import base64
import json

def encode_image(path):
    with open(path, "rb") as f:
        b64 = base64.standard_b64encode(f.read()).decode("utf-8")
    return f"data:image/jpeg;base64,{b64}"

def quality_control(reference_image, sample_image):
    """Compara una muestra con su referencia y detecta defectos."""
    response = client.chat.complete(
        model="mistral-large-latest",
        response_format={"type": "json_object"},
        messages=[
            {
                "role": "system",
                "content": "Eres un inspector de calidad. Compara la muestra con la referencia y devuelve un informe en JSON."
            },
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Referencia (producto conforme):"},
                    {"type": "image_url", "image_url": encode_image(reference_image)},
                    {"type": "text", "text": "Muestra a inspeccionar:"},
                    {"type": "image_url", "image_url": encode_image(sample_image)},
                    {
                        "type": "text",
                        "text": """Compara y devuelve:
{
  "compliant": true/false,
  "compliance_score": 0-100,
  "defects": [
    {"description": "...", "severity": "minor/major/critical", "location": "..."}
  ],
  "recommendation": "accept/review/reject"
}"""
                    }
                ]
            }
        ]
    )

    return json.loads(response.choices[0].message.content)

# Uso
result = quality_control("reference/product-ok.jpg", "batch-42/sample-7.jpg")

if result["compliant"]:
    print(f"CONFORME - Puntuación: {result['compliance_score']} %")
else:
    print(f"NO CONFORME - {len(result['defects'])} defecto(s) detectado(s)")
    for defect in result["defects"]:
        print(f"  - [{defect['severity']}] {defect['description']}")

El campo recommendation es más interesante de lo que parece: al distinguir «review» (revisar) de «reject» (rechazar), reserva la intervención humana para casos ambiguos en lugar de imponerla en todas partes o en ninguna.

Seguimiento de la evolución en el tiempo

Una serie temporal —obra en construcción, crecimiento de cultivos, degradación de una estructura— se trata como una comparación ampliada, siempre que etiquetes cada imagen con su fecha. El modelo dispone entonces del eje temporal y puede calificar un ritmo, no solo una brecha.

def analyze_evolution(chronological_images, context=""):
    """Analiza la evolución visible a través de una serie de imágenes ordenadas."""
    content = [
        {
            "type": "text",
            "text": f"Aquí tienes {len(chronological_images)} imágenes tomadas en momentos diferentes, en orden cronológico. {context}"
        }
    ]

    for i, (date, path) in enumerate(chronological_images):
        content.append({"type": "text", "text": f"Imagen {i+1} ({date}):"})
        content.append({"type": "image_url", "image_url": encode_image(path)})

    content.append({
        "type": "text",
        "text": "Describe la evolución observada entre cada paso. Identifica los cambios principales y la tendencia general."
    })

    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": content}]
    )

    return response.choices[0].message.content

# Seguimiento de una obra
images = [
    ("2025-01", "site/jan-2025.jpg"),
    ("2025-06", "site/jun-2025.jpg"),
    ("2026-01", "site/jan-2026.jpg"),
]

evolution = analyze_evolution(images, context="Seguimiento de una obra en construcción.")
print(evolution)

La pregunta final se añade solo después de todas las imágenes, una vez desplegado el conjunto completo.

Comparación de interfaces de usuario

El desarrollo web ofrece un caso de uso inmediato: confrontar el mockup aprobado con el renderizado realmente producido. Mientras que una prueba de regresión de píxeles falla ante un desplazamiento de un píxel sin importancia, el modelo califica el impacto de cada discrepancia.

def compare_interfaces(expected_screenshot, actual_screenshot):
    """Compara dos capturas de pantalla de una interfaz para detectar regresiones visuales."""
    response = client.chat.complete(
        model="mistral-large-latest",
        response_format={"type": "json_object"},
        messages=[
            {
                "role": "system",
                "content": "Eres un tester de QA especializado en pruebas visuales de interfaces web."
            },
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Diseño esperado (mockup):"},
                    {"type": "image_url", "image_url": encode_image(expected_screenshot)},
                    {"type": "text", "text": "Renderizado actual (captura):"},
                    {"type": "image_url", "image_url": encode_image(actual_screenshot)},
                    {
                        "type": "text",
                        "text": """Compara y devuelve:
{
  "pixel_perfect": true/false,
  "differences": [
    {"element": "...", "expected": "...", "actual": "...", "impact": "minor/moderate/major"}
  ],
  "fidelity_score": 0-100,
  "verdict": "compliant/minor_adjustments/regression"
}"""
                    }
                ]
            }
        ]
    )

    return json.loads(response.choices[0].message.content)

Integrada en tu pipeline de integración continua, esta comprobación bloquea la entrega solo ante un veredicto regression.

Mejores prácticas para la comparación

Estos ejemplos comparten algunos principios que merece la pena explicitar. Nombra siempre tus imágenes con una etiqueta intercalada —«Referencia», «Muestra», «Antes», «Después»— porque, sin ella, el modelo asigna roles basándose en el azar del orden. Asegura la comparabilidad de las tomas: con ángulos e iluminación distintos, el modelo señalará discrepancias que provienen únicamente de las condiciones de la fotografía. Usa Mistral Large 3, porque la comparación moviliza un razonamiento de grano fino que los modelos más pequeños no siempre dominan. Limítate a dos o tres imágenes por llamada; más allá de eso, la precisión comparativa se diluye. Y solicita sistemáticamente un formato estructurado, con una puntuación, diferencias listadas y un veredicto, si el resultado debe procesarse automáticamente.

Puntos clave

  • La comparación de imágenes aprovecha la capacidad de múltiples imágenes de la API
  • Intercala texto explicativo entre imágenes para clarificar sus funciones
  • El modo JSON (response_format) es ideal para informes de comparación automatizados
  • Casos de uso principales: control de calidad, seguimiento de obras, QA visual, antes/después
  • Usa siempre Mistral Large 3 para tareas de comparación exigentes