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

CI/CD para IA: Evaluaciones automatizadas

Lección 18 de 20 Actualizado el 3 de noviembre de 2026 Avanzado
En esta página
  1. Integración de evaluaciones en tu pipeline de CI/CD
  2. El principio: una puerta, no un informe
  3. Conexión de todo en GitHub Actions
  4. Comparar en lugar de juzgar en términos absolutos
  5. 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.

Integración de evaluaciones en tu pipeline de CI/CD

Desplegar un cambio en un prompt a producción sin evaluación es como desplegar código sin pruebas. La comparación es más acertada de lo que parece: en ambos casos, el cambio parece trivial, se ha verificado manualmente en uno o dos ejemplos y el efecto secundario aparece tres días después para un usuario que no te lo comunicará. La diferencia es que una regresión en un prompt no lanza una excepción; la aplicación sigue respondiendo, solo que peor.

El objetivo es convertir la evaluación automatizada en una puerta obligatoria en tu proceso de despliegue, garantizando que cada cambio mantenga o mejore la calidad. Eso es exactamente lo que veremos a continuación.

El principio: una puerta, no un informe

El pipeline de evaluación se integra en tu flujo de despliegue mediante un mecanismo familiar. Un desarrollador modifica un prompt o un parámetro, el commit activa el pipeline de CI y las evaluaciones se ejecutan automáticamente contra el conjunto de datos de referencia. Si las puntuaciones cumplen los umbrales, el despliegue continúa; de lo contrario, se bloquea, generando un informe detallado que indica qué evaluación ha fallado y en qué medida.

El punto crítico es ese comportamiento de bloqueo. Un CI que produce un informe bonito sin detener el pipeline se convierte en un artefacto que nadie consulta pasadas dos semanas. Solo un código de salida distinto de cero convierte la medición en una barrera de seguridad.

El siguiente script lee una configuración, carga cada conjunto de datos, ejecuta los casos y compara la puntuación media con el umbral declarado. El método de puntuación —inclusión simple de palabras clave— es intencionadamente rudimentario: una comprobación de CI debe ser rápida, determinista e independiente de un juez cuya puntuación podría variar de una ejecución a otra.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Carga la configuración de evaluación."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Carga un conjunto de datos JSONL."""
    cases = []
    with open(path) as f:
        for line in f:
            cases.append(json.loads(line))
    return cases

def run_ci_evals(config: dict) -> dict:
    """Ejecuta evaluaciones para CI."""
    results = {}

    for eval_config in config["evaluations"]:
        name = eval_config["name"]
        dataset = load_dataset(eval_config["dataset"])
        threshold = eval_config["min_threshold"]
        model = eval_config["model"]
        prompt = Path(eval_config["prompt_file"]).read_text()

        scores = []
        for case in dataset:
            response = client.responses.create(
                model=model,
                reasoning={"effort": "none"},  # temperature requiere effort none
                instructions=prompt,
                input=case["input"],
                temperature=0.0,
            )

            # Evaluación simple por inclusión de palabras clave
            if "keywords" in case:
                response_lower = response.output_text.lower()
                found = sum(
                    1 for word in case["keywords"]
                    if word.lower() in response_lower
                )
                score = found / len(case["keywords"])
            else:
                score = 1.0  # Sin criterio específico

            scores.append(score)

        avg_score = sum(scores) / len(scores)
        passed = avg_score >= threshold

        results[name] = {
            "score": avg_score,
            "threshold": threshold,
            "passed": passed,
            "num_cases": len(dataset),
        }

    return results

def ci_report(results: dict) -> tuple[str, bool]:
    """Genera un informe para CI e indica si todo está correcto."""
    lines = ["# Informe de evaluación de IA\n"]
    all_pass = True

    for name, r in results.items():
        status = "PASS" if r["passed"] else "FAIL"
        if not r["passed"]:
            all_pass = False
        lines.append(
            f"- [{status}] {name}: {r['score']:.2%} "
            f"(umbral: {r['threshold']:.0%}, {r['num_cases']} casos)"
        )

    report = "\n".join(lines)
    return report, all_pass

Observa que el prompt se lee desde un archivo en lugar de escribirse directamente en el script. Esto es lo que hace posible el desencadenante: un prompt versionado en el repositorio produce un diff, y un diff puede activar una evaluación. Mientras tus prompts vivan como literales de cadena dispersos por el código de tu aplicación, la automatización adecuada no será posible.

La configuración declara una evaluación por tarea, cada una con su propio umbral.

{
  "evaluations": [
    {
      "name": "ticket-classification",
      "dataset": "evals/datasets/classification.jsonl",
      "prompt_file": "prompts/classification.txt",
      "model": "gpt-5.6-terra",
      "min_threshold": 0.90
    },
    {
      "name": "resume-generation",
      "dataset": "evals/datasets/resumes.jsonl",
      "prompt_file": "prompts/resume.txt",
      "model": "gpt-5.6-terra",
      "min_threshold": 0.75
    }
  ]
}

La brecha entre estos dos umbrales es el corazón del método. La clasificación de tickets es una tarea cerrada: por debajo de 0,90, la función no ofrece el servicio esperado. La generación de resúmenes es una tarea abierta, juzgada por palabras clave que un buen texto podría legítimamente formular de manera diferente; exigir 0,90 bloquearía cada despliegue y llevaría rápidamente a desactivar la comprobación. Calibra cada umbral basándote en las puntuaciones observadas en producción, no en un número redondo que resulte tranquilizador.

Conexión de todo en GitHub Actions

El flujo de trabajo se activa solo en rutas relevantes —prompts, evaluaciones, código de integración de IA—, de modo que un cambio en una hoja de estilos no consuma llamadas a la API.

# .github/workflows/eval-ai.yml
name: AI Evaluation

on:
  pull_request:
    paths:
      - "prompts/**"
      - "evals/**"
      - "src/ai/**"

jobs:
  evaluate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - run: pip install openai

      - name: Run evals
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: python evals/run_ci.py

      - name: Publish report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: eval-report
          path: evals/report.md

Dos detalles merecen atención. La clave de la API se pasa a través de los secretos del repositorio, nunca a través del archivo de flujo de trabajo, que es legible por cualquiera con acceso al código. Y la publicación del informe usa if: always(), de lo contrario el artefacto no se produciría cuando las evaluaciones fallan, que es precisamente el único caso en el que necesitas leerlo.

El script de entrada une todo: escribe el informe en el disco para el artefacto, lo imprime en los registros y establece el código de salida que permite o bloquea el resto del pipeline.

#!/usr/bin/env python3
"""Script de evaluación para CI — evals/run_ci.py"""

import sys
from pathlib import Path

def main():
    config = load_eval_config("evals/config.json")
    results = run_ci_evals(config)
    report, all_pass = ci_report(results)

    # Escribir el informe
    Path("evals/report.md").write_text(report)
    print(report)

    # Código de salida para CI
    if not all_pass:
        print("\nAlgunas evaluaciones han fallado. Despliegue bloqueado.")
        sys.exit(1)
    else:
        print("\nTodas las evaluaciones han pasado.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Comparar en lugar de juzgar en términos absolutos

Un umbral fijo responde a la pregunta «¿Es esto suficientemente bueno?». No responde a «¿Es esto mejor que antes?», que a menudo es la pregunta real. Un prompt reescrito puede mantenerse por encima del umbral mientras pierde tres puntos respecto a la versión anterior: el CI se pone en verde y la degradación entra en producción sin que nadie lo note.

La prueba de regresión ejecuta, por tanto, ambas versiones sobre el mismo conjunto de datos, en la misma campaña, y compara las medias. Una tolerancia del 5 % absorbe el ruido inherente a las salidas generativas; más allá de eso, el veredicto es explícito.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Verifica que un nuevo prompt no degrade el rendimiento."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Evaluar con el prompt actual
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature requiere effort none
            input=case["input"], temperature=0.0,
        )
        # Evaluar con el prompt anterior
        r2 = client.responses.create(
            model=model, instructions=previous_prompt,
            reasoning={"effort": "none"},  # temperature requiere effort none
            input=case["input"], temperature=0.0,
        )

        s1 = evaluate_response(r1.output_text, case)
        s2 = evaluate_response(r2.output_text, case)
        scores_current.append(s1)
        scores_previous.append(s2)

    avg_current = sum(scores_current) / len(scores_current)
    avg_previous = sum(scores_previous) / len(scores_previous)
    delta = avg_current - avg_previous

    return {
        "current_score": avg_current,
        "previous_score": avg_previous,
        "delta": delta,
        "regression": delta < -degradation_threshold,
        "verdict": "OK" if delta >= -degradation_threshold else "REGRESSION",
    }

Esta prueba duplica el número de llamadas y, por tanto, el coste y la duración. Resérvala para cambios en los prompts, manteniéndola fuera de la ruta de los commits ordinarios, y ejecútala sobre un subconjunto representativo en lugar de sobre todo tu conjunto de datos de referencia.

Puntos clave

  • Integra las evaluaciones en tu pipeline de CI/CD como si fueran pruebas unitarias.
  • Versiona los prompts en archivos: sin un diff, no es posible ningún desencadenante.
  • Define umbrales mínimos por tipo de evaluación, calibrados con datos de producción.
  • Bloquea los despliegues mediante el código de salida cuando las puntuaciones caigan por debajo de los umbrales.
  • Prueba las regresiones comparando los prompts nuevos y antiguos sobre el mismo conjunto de datos.