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

Pruebas A/B de prompts

Lección 15 de 16 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Pruebas A/B de prompts
  2. Principio
  3. Marco de pruebas A/B
  4. Métricas de evaluación
  5. Ejemplo completo: probar dos estilos de prompt
  6. Significancia estadística
  7. Ejecución de tu primer experimento
  8. Puntos clave

Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI: temperature y top_p solo se aceptan con un esfuerzo de razonamiento de none, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificar reasoning={"effort": "none"} (API de Responses) o reasoning_effort="none" (Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.

Pruebas A/B de prompts

Las pruebas A/B de prompts te permiten comparar objetivamente dos versiones de un prompt utilizando tráfico real. En lugar de elegir un prompt basándote en la intuición, mides cuál produce mejores resultados según tus métricas de negocio. Este es el paso obligatorio entre la creación de prototipos y la puesta en producción.

Principio

El tráfico entrante se divide aleatoriamente entre dos (o más) variantes de prompt. Cada respuesta se evalúa frente a criterios predefinidos y la variante ganadora se despliega al 100 % del tráfico.

La ventaja de este método es que ambas variantes se enfrentan al mismo tráfico, en las mismas condiciones y al mismo tiempo. Todas las fuentes externas de variación —estacionalidad, incidentes de red, la llegada de una nueva categoría de solicitudes— afectan a ambos grupos por igual y se cancelan en la comparación. Una prueba secuencial no puede garantizar esto: ejecutar el prompt antiguo durante una semana y el nuevo la siguiente te impide saber si la mejora provino de tu reescritura o del calendario.

Marco de pruebas A/B

La clase PromptExperiment tiene tres responsabilidades. assign_variant decide qué variante atiende una solicitud dada, run ejecuta la llamada y registra el resultado, y get_stats agrega los datos.

La asignación merece una nota. Cuando se proporciona un user_id, es determinista, calculado a partir de un hash del par experimento-usuario. El mismo usuario permanece en el mismo grupo de una llamada a la siguiente. Esta continuidad no es un refinamiento teórico: un cliente que recibe una respuesta cálida y luego, tres minutos después, una respuesta seca a su seguimiento pensará que es un error, y su insatisfacción contaminará ambas variantes.

Cada ejecución registra la entrada, la salida, los tokens consumidos y la marca de tiempo. Estos tokens no están ahí por decoración: una variante podría ganar en calidad mientras duplica la longitud de la respuesta, y _estimate_cost traduce esa brecha a dólares para que puedas tomar una decisión informada sobre el compromiso.

import random
import json
from datetime import datetime
from openai import OpenAI

client = OpenAI()

class PromptExperiment:
    """Marco de pruebas A/B para prompts."""

    def __init__(self, name: str, variants: dict[str, dict]):
        """
        variants = {
            "control": {"system_prompt": "...", "model": "gpt-5.6-terra",
                        "temperature": 0.3},
            "variant_a": {"system_prompt": "...", "model": "gpt-5.6-terra",
                          "temperature": 0.1},
        }
        """
        self.name = name
        self.variants = variants
        self.results = {v: [] for v in variants}

    def assign_variant(self, user_id: str = None) -> str:
        """Asigna una variante (fija por user_id si se proporciona)."""
        if user_id:
            # Asignación determinista por usuario
            hash_val = hash(f"{self.name}:{user_id}") % 100
            keys = sorted(self.variants.keys())
            split = 100 // len(keys)
            for i, key in enumerate(keys):
                if hash_val < (i + 1) * split:
                    return key
            return keys[-1]
        return random.choice(list(self.variants.keys()))

    def run(self, input_text: str, user_id: str = None,
            schema: dict = None) -> dict:
        """Ejecuta el prompt con la variante asignada."""
        variant_name = self.assign_variant(user_id)
        variant = self.variants[variant_name]

        kwargs = {
            "model": variant["model"],
            "instructions": variant["system_prompt"],
            "input": input_text,
            "temperature": variant.get("temperature", 0.3)
        }

        if schema:
            kwargs["text"] = {
                "format": {
                    "type": "json_schema",
                    "name": "response",
                    "schema": schema,
                    "strict": True
                }
            }

        response = client.responses.create(**kwargs)

        result = {
            "variant": variant_name,
            "input": input_text,
            "output": response.output_text,
            "tokens_input": response.usage.input_tokens,
            "tokens_output": response.usage.output_tokens,
            "timestamp": datetime.now().isoformat()
        }

        self.results[variant_name].append(result)
        return result

    def get_stats(self) -> dict:
        """Calcula estadísticas por variante."""
        stats = {}
        for variant, results in self.results.items():
            if not results:
                continue
            tokens_in = [r["tokens_input"] for r in results]
            tokens_out = [r["tokens_output"] for r in results]
            stats[variant] = {
                "count": len(results),
                "avg_tokens_input": sum(tokens_in) / len(tokens_in),
                "avg_tokens_output": sum(tokens_out) / len(tokens_out),
                "total_cost_estimate": self._estimate_cost(
                    sum(tokens_in), sum(tokens_out)
                )
            }
        return stats

    def _estimate_cost(self, tokens_in: int,
                        tokens_out: int) -> float:
        """Estima el coste en USD."""
        return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000

Métricas de evaluación

Las métricas dependen de tu caso de uso, y dos familias cubren la mayoría de los escenarios. Cuando la tarea tiene una respuesta correcta —clasificar un ticket, extraer un campo—, la evaluación se reduce a comparar con una etiqueta de referencia. Esta es la función de evaluer_classification. Observa una elección instructiva aquí: los fallos de análisis se tratan como predicciones vacías en lugar de lanzar una excepción, porque una variante que produce JSON no válido debe ser penalizada en la puntuación, no hacer fallar la medición.

Cuando la tarea produce texto libre, no hay una única respuesta correcta, por lo que pides al modelo que arbitre. evaluer_qualite_texte desglosa el juicio en cuatro criterios —relevancia, claridad, completitud, tono profesional— en lugar de pedir una puntuación global directa. Este desglose hace que la evaluación sea más estable y te indica en qué eje destaca la variante ganadora: saber que la ganancia proviene del tono y no de la completitud es precisamente la información que necesitas para escribir la siguiente versión.

def evaluer_classification(result: dict,
                            label_attendu: str) -> dict:
    """Evalúa una respuesta de clasificación."""
    try:
        output = json.loads(result["output"])
        prediction = output.get("category", "")
    except json.JSONDecodeError:
        prediction = ""

    return {
        "correct": prediction == label_attendu,
        "prediction": prediction,
        "attendu": label_attendu
    }

def evaluer_qualite_texte(result: dict) -> dict:
    """Evalúa la calidad de una respuesta de texto usando el LLM."""
    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requiere effort none
        instructions="Eres un evaluador de calidad de texto. "
                     "Puntúa del 1 al 10 basándote en: relevancia, claridad, "
                     "completitud, tono profesional.",
        input=f"Pregunta: {result['input']}\n\n"
              f"Respuesta: {result['output']}",
        text={
            "format": {
                "type": "json_schema",
                "name": "evaluation",
                "schema": {
                    "type": "object",
                    "properties": {
                        "pertinence": {"type": "integer"},
                        "clarte": {"type": "integer"},
                        "completude": {"type": "integer"},
                        "ton": {"type": "integer"},
                        "note_globale": {"type": "number"},
                        "commentaire": {"type": "string"}
                    },
                    "required": ["pertinence", "clarte",
                                 "completude", "ton",
                                 "note_globale", "commentaire"],
                    "additionalProperties": False
                },
                "strict": True
            }
        },
        temperature=0.1
    )
    return json.loads(eval_response.output_text)

Ejemplo completo: probar dos estilos de prompt

El siguiente experimento contrasta dos enfoques para la atención al cliente. El control utiliza una instrucción mínima, profesional y neutra. La variante “empática” impone una estructura de tres pasos: reconocer el problema, expresar empatía y luego proponer una solución con pasos. Todo lo demás es idéntico, desde el modelo hasta la temperatura. Esta simetría es la condición para atribuir cualquier brecha medida al prompt. Cambiar tanto el tono como la temperatura a la vez daría un resultado ininterpretable.

Los cinco tickets de prueba cubren deliberadamente diferentes registros: un incidente de entrega cargado emocionalmente, un error funcional, una pregunta neutral sobre contraseñas, una solicitud de reembolso controvertida y una interrupción de la API reportada por un perfil técnico. Esperas que la variante empática domine los dos primeros y sea penalizada en el último, donde el interlocutor quiere un estado y un tiempo estimado de resolución, no compasión. Este es el matiz que un promedio global oculta y que un examen ticket por ticket revela, lo que a menudo lleva a la decisión real: enrutar según el tipo de solicitud en lugar de elegir un único tono.

experiment = PromptExperiment(
    name="customer-support-style",
    variants={
        "control": {
            "system_prompt": "Eres un agente de soporte. "
                             "Responde de forma profesional.",
            "model": "gpt-5.6-terra",
            "temperature": 0.3
        },
        "empathique": {
            "system_prompt": "Eres un agente de soporte empático. "
                             "Comienza reconociendo el problema del cliente, "
                             "muestra empatía y luego propone una solución concreta "
                             "con pasos.",
            "model": "gpt-5.6-terra",
            "temperature": 0.3
        }
    }
)

# Simular tráfico
test_tickets = [
    "Mi paquete no ha llegado en 2 semanas.",
    "La aplicación se cierra cuando hago clic en Configuración.",
    "¿Cómo cambio mi contraseña?",
    "Quiero un reembolso, el producto es defectuoso.",
    "Vuestra API lleva devolviendo un error 500 desde esta mañana.",
]

for ticket in test_tickets:
    result = experiment.run(ticket)
    quality = evaluer_qualite_texte(result)
    print(f"Variante: {result['variant']} | "
          f"Puntuación: {quality['note_globale']}/10")

print("\nEstadísticas:")
print(json.dumps(experiment.get_stats(), indent=2))

Significancia estadística

No saques conclusiones demasiado rápido. Con pocos datos, los resultados son ruidosos, y el error clásico es ver 7,4 frente a 6,9 en doce observaciones y declarar un ganador. La prueba t de Student a continuación responde a la única pregunta que importa: ¿es la brecha observada mayor que la que el azar produciría naturalmente entre dos series equivalentes?

Un p_value inferior a 0,05 significa que tal brecha sería poco probable si las dos variantes fueran iguales. Por encima de eso, no has demostrado nada, lo cual no es lo mismo que demostrar igualdad. Lo más habitual es que simplemente carezcas de datos. Cuenta con un mínimo de cien observaciones por variante antes de concluir, y ten cuidado con el impulso de comprobar los resultados cada mañana. Si miras lo suficiente, siempre encontrarás un momento en el que la brecha parezca significativa.

from scipy import stats

def test_significativite(scores_a: list[float],
                          scores_b: list[float]) -> dict:
    """Prueba t de Student para comparar dos variantes."""
    t_stat, p_value = stats.ttest_ind(scores_a, scores_b)

    return {
        "moyenne_a": sum(scores_a) / len(scores_a),
        "moyenne_b": sum(scores_b) / len(scores_b),
        "p_value": p_value,
        "significatif": p_value < 0.05,
        "recommandation": (
            "Diferencia significativa, despliega la variante ganadora"
            if p_value < 0.05
            else "Datos insuficientes o sin diferencia significativa"
        )
    }

Ejecución de tu primer experimento

Toma una tarea que conozcas bien y configura un PromptExperiment con dos variantes, cambiando solo una cosa entre el control y la variante: un tono, una estructura impuesta o una instrucción adicional. Define dos o tres métricas antes de lanzar nada, porque elegir la métrica después de ver los resultados es como elegir al ganador de antemano, y es el sesgo más común en las pruebas caseras.

Ejecuta el experimento con veinte entradas y luego analiza. Mira el promedio, pero sobre todo abre los casos en los que las dos variantes divergen más: estos explican la brecha. Veinte observaciones obviamente no serán suficientes para alcanzar la significancia, y darte cuenta de ello por ti mismo es mejor que leerlo aquí. Finalmente, documenta la decisión y archiva los resultados brutos con la fecha y la configuración exacta de la variante; este archivo es lo que te impedirá ejecutar el mismo experimento de nuevo dentro de un año.

Puntos clave

  • Las pruebas A/B sustituyen la intuición por datos medibles
  • Asigna variantes de forma determinista por usuario
  • Mide métricas de negocio, no solo la calidad percibida
  • Espera a la significancia estadística antes de concluir
  • Documenta cada experimento y sus resultados