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

Comparación con el modelo base

Lección 11 de 16 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Por qué importa la comparación sistemática
  2. Define la línea base
  3. Genera respuestas lado a lado
  4. Haz que un modelo tercero actúe como juez
  5. Compara costes
  6. Compara la latencia
  7. Decide en función de los resultados
  8. Puntos clave

Actualización 2 de noviembre de 2026 — Disponibilidad del ajuste fino. OpenAI está eliminando gradualmente el ajuste fino de autoservicio: desde el 7 de mayo de 2026, las organizaciones que nunca lo han utilizado ya no pueden crear trabajos; desde el 2 de julio, debes haber usado un modelo ajustado en los últimos 60 días; y a partir del 6 de enero de 2027, ningún cliente podrá lanzar nuevos trabajos. Los modelos ya entrenados seguirán siendo utilizables hasta que se retire su modelo base. Este curso sigue siendo útil para comprender y aprovechar un modelo existente; para nuevos proyectos, prioriza la ingeniería de prompts, RAG y las evaluaciones.

Por qué importa la comparación sistemática

El ajuste fino tiene un coste: tiempo de preparación de datos, gastos de entrenamiento y complejidad de mantenimiento. Debes demostrar que tu modelo ajustado ofrece una mejora medible frente al modelo base con un prompt sólido. Si la diferencia es marginal, es posible que el ajuste fino no merezca la pena.

La tentación en este ejercicio es comparar tu modelo entrenado contra un modelo base mal instruido. Eso da lugar a una demostración halagadora pero inútil: has vencido a un oponente que tú mismo has debilitado. La única comparación honesta enfrenta tu modelo ajustado contra el mejor uso posible del modelo base.

Define la línea base

La línea base es el modelo base con tu mejor prompt de sistema. Optimiza este prompt antes de comparar. Concretamente, esto significa escribir las reglas que implícitamente enseñaste mediante ejemplos durante el ajuste fino: el rol, el tono, la longitud esperada y cómo cerrar un intercambio. El siguiente prompt hace exactamente eso para un asistente de soporte; ten en cuenta que el modelo ajustado no necesita tales instrucciones, ya que estas reglas forman ahora parte de sus pesos.

from openai import OpenAI

client = OpenAI()

OPTIMIZED_SYSTEM_PROMPT = """Eres un asistente de atención al cliente para TechCorp.
Reglas:
- Responde de forma profesional y empática
- Propón siempre una solución concreta
- Limita las respuestas a un máximo de 3 frases
- Termina con una pregunta de seguimiento"""

def baseline_response(question: str) -> str:
    """Obtiene una respuesta del modelo base."""
    response = client.responses.create(
        model="gpt-5.6-luna",
        instructions=OPTIMIZED_SYSTEM_PROMPT,
        input=question
    )
    return response.output_text

def fine_tune_response(question: str, model_ft: str) -> str:
    """Obtiene una respuesta del modelo ajustado."""
    response = client.responses.create(
        model=model_ft,
        input=question
    )
    return response.output_text

Genera respuestas lado a lado

El siguiente paso es consultar ambos modelos con exactamente las mismas preguntas y conservar las respuestas emparejadas. Elige preguntas representativas de tu tráfico real en lugar de casos de libro de texto: una reclamación por entrega, una solicitud de procedimiento, insatisfacción, una solicitud de reembolso, una pregunta factual. Estas cinco familias marcan la diferencia en producción, no la redacción perfecta.

import json

def compare_models(
    questions: list[str],
    base_model: str,
    ft_model: str,
    system_prompt: str
) -> list[dict]:
    """Compara las respuestas de dos modelos ante las mismas preguntas."""
    comparisons = []

    for q in questions:
        # Modelo base con prompt optimizado
        r_base = client.responses.create(
            model=base_model,
            instructions=system_prompt,
            input=q
        )

        # Modelo ajustado (prompt mínimo o nulo)
        r_ft = client.responses.create(
            model=ft_model,
            input=q
        )

        comparisons.append({
            "question": q,
            "baseline_response": r_base.output_text,
            "ft_response": r_ft.output_text
        })

    return comparisons

# Preguntas de prueba
test_questions = [
    "Mi paquete no ha llegado.",
    "¿Cómo restablezco mi contraseña?",
    "Su producto no funciona como se esperaba.",
    "Quisiera un reembolso.",
    "¿Cuál es su horario de apertura?",
]

results = compare_models(
    test_questions,
    "gpt-5.6-luna",
    "ft:gpt-5.6-luna:org::suffix:xxxxxxxx",
    OPTIMIZED_SYSTEM_PROMPT
)

Haz que un modelo tercero actúe como juez

Leer cien pares a mano se vuelve rápidamente desalentador, y el juicio se resiente conforme avanza la fatiga. Un modelo tercero, que no ha generado ninguna de las dos respuestas, arbitra cada par según cuatro criterios y emite un veredicto global. Primero, neutraliza las etiquetas: el juez ve «Respuesta A» y «Respuesta B», nunca qué modelo las produjo; de lo contrario, su veredicto ponderará el nombre del modelo tanto como el texto. A continuación, gestiona los casos en los que la salida no sea analizable; de otro modo, una sola respuesta mal formada detendría toda la campaña.

def judge_comparison(comparison: dict) -> dict:
    """Hace que un modelo tercero juzgue la comparación."""
    prompt = f"""Compara estas dos respuestas a la misma pregunta.

Pregunta: {comparison['question']}

Respuesta A: {comparison['baseline_response']}

Respuesta B: {comparison['ft_response']}

Para cada criterio, indica qué respuesta es mejor (A, B o empate):
1. Pertinencia de la respuesta
2. Profesionalidad del tono
3. Adherencia al formato esperado
4. Utilidad para el usuario

Responde en JSON: {{"relevance": "A/B/tie", "tone": "A/B/tie", "format": "A/B/tie", "usefulness": "A/B/tie", "overall_winner": "A/B/tie"}}"""

    response = client.responses.create(
        model="gpt-5.6-sol",
        input=prompt
    )

    try:
        return json.loads(response.output_text)
    except json.JSONDecodeError:
        return {"error": "Respuesta no analizable"}

# Juzgar todas las comparaciones
judgments = [judge_comparison(c) for c in results]

Ahora agrega estos veredictos en una única cifra. La tasa de mejora —la proporción de pares en los que gana el modelo ajustado— se lee frente a umbrales predefinidos: por encima del 60 %, la ganancia es clara; entre el 40 % y el 60 %, pondera la ganancia frente al coste adicional; por debajo de eso, tu ajuste fino no se ha demostrado, y el problema casi siempre reside en los datos.

def comparison_score(judgments: list[dict]) -> dict:
    """Calcula la puntuación global de la comparación."""
    scores = {"A_wins": 0, "B_wins": 0, "tie": 0}

    for j in judgments:
        winner = j.get("overall_winner", "tie")
        if winner == "A":
            scores["A_wins"] += 1
        elif winner == "B":
            scores["B_wins"] += 1
        else:
            scores["tie"] += 1

    total = len(judgments)
    print(f"Victorias del modelo base: {scores['A_wins']}/{total}")
    print(f"Victorias del modelo ajustado: {scores['B_wins']}/{total}")
    print(f"Empates: {scores['tie']}/{total}")

    improvement_rate = scores["B_wins"] / total * 100
    print(f"\nTasa de mejora: {improvement_rate:.1f}%")

    if improvement_rate >= 60:
        print("El ajuste fino proporciona una mejora significativa.")
    elif improvement_rate >= 40:
        print("Mejora modesta: comprueba si el coste está justificado.")
    else:
        print("El ajuste fino no proporciona una mejora clara.")

    return scores

comparison_score(judgments)

Compara costes

La calidad es solo la mitad de la decisión. El ajuste fino a menudo reduce los tokens de entrada, ya que el prompt largo se vuelve innecesario, pero cada token facturado en un modelo ajustado cuesta más. Estos dos efectos tiran en direcciones opuestas, y solo el cálculo decide. La función siguiente los enfrenta durante un mes de tráfico: un prompt que pasa de 500 a 50 tokens compensa con creces una tarifa de entrada duplicada, pero eso no se cumpliría con un prompt base ya corto.

def compare_costs(
    requests_per_day: int,
    base_prompt_tokens: int,
    ft_prompt_tokens: int,
    avg_output_tokens: int,
    base_input_price: float,
    ft_input_price: float,
    output_price: float
):
    """Compara los costes mensuales entre modelos base y ajustados."""
    days = 30

    base_cost = days * requests_per_day * (
        base_prompt_tokens * base_input_price / 1_000_000 +
        avg_output_tokens * output_price / 1_000_000
    )

    ft_cost = days * requests_per_day * (
        ft_prompt_tokens * ft_input_price / 1_000_000 +
        avg_output_tokens * output_price / 1_000_000
    )

    savings = base_cost - ft_cost
    print(f"Coste mensual base: ${base_cost:.2f}")
    print(f"Coste mensual ajustado: ${ft_cost:.2f}")
    print(f"Ahorro mensual: ${savings:.2f}")

# Ejemplo
compare_costs(
    requests_per_day=1000,
    base_prompt_tokens=500,   # prompt largo con instrucciones
    ft_prompt_tokens=50,       # prompt corto, comportamiento integrado
    avg_output_tokens=200,
    base_input_price=0.15,
    ft_input_price=0.30,        # el ajustado cuesta más por token
    output_price=0.60
)

Compara la latencia

Acortar un prompt en varios cientos de tokens también afecta al tiempo de respuesta, un criterio que tus usuarios notan mucho antes que los matices del tono. Mide la latencia con las mismas preguntas utilizadas para la comparación cualitativa, fuera de las horas punta, y repite la medición varias veces: un único valor refleja mayoritariamente el estado de la red en el momento de la prueba.

import time

def measure_latency(model: str, questions: list[str], prompt: str = "") -> float:
    """Mide la latencia media de un modelo."""
    latencies = []
    for q in questions:
        start = time.time()
        kwargs = {"model": model, "input": q}
        if prompt:
            kwargs["instructions"] = prompt
        client.responses.create(**kwargs)
        latencies.append(time.time() - start)

    avg = sum(latencies) / len(latencies)
    print(f"{model} — Latencia media: {avg:.2f}s")
    return avg

Decide en función de los resultados

Ahora cruza calidad y coste. Cada combinación exige una decisión diferente, y la más incómoda sigue siendo el término medio: cuando los dos modelos son iguales, debes abandonar el trabajo ya pagado en lugar de buscar una justificación a posteriori.

ResultadoAcción
El modelo ajustado gana en calidad + costesDespliega el modelo ajustado
El modelo ajustado gana en calidad, pierde en costesEvalúa si la calidad justifica el coste adicional
Resultados similaresQuédate con el modelo base + prompt
Gana el modelo baseMejora tus datos y vuelve a intentarlo

Puntos clave

  • Compara siempre contra un modelo base + prompt optimizado, no contra un prompt básico
  • Utiliza el juicio de un LLM para automatizar la comparación cualitativa
  • Mide costes y latencia, no solo calidad
  • Una tasa de mejora superior al 60 % justifica el ajuste fino
  • Si el ajuste fino no proporciona una mejora clara, quédate con la ingeniería de prompts