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

Seguimiento del entrenamiento

Lección 7 de 16 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Por qué monitorizar el entrenamiento
  2. Las dos métricas que debes leer
  3. Seguimiento de eventos mediante la API
  4. Puntos de control y resultados intermedios
  5. Saber cuándo detenerse
  6. Un informe resumen por ejecución
  7. Puntos clave

Actualización 2 de noviembre de 2026 — Disponibilidad del ajuste fino. El servicio de ajuste fino de autoservicio de OpenAI está siendo retirado gradualmente: desde el 7 de mayo de 2026, las organizaciones que nunca lo han utilizado ya no pueden crear tareas; desde el 2 de julio, es necesario 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 nuevas tareas. 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é monitorizar el entrenamiento

Lanzar una tarea de ajuste fino y olvidarte de ella te deja con un hecho consumado: una hora después, descubres un modelo sin saber qué ha ocurrido entretanto. Al observar las métricas mientras se ejecuta el entrenamiento, detectas problemas pronto, decides ajustar los hiperparámetros antes de quemar todo tu presupuesto y, sobre todo, comprendes por qué una ejecución ha rendido más que otra. El seguimiento convierte una serie de pruebas en una disciplina de ingeniería.

Las dos métricas que debes leer

La pérdida de entrenamiento (training loss) mide cuán equivocado está el modelo con los datos de entrenamiento, es decir, los mismos datos que está ingiriendo en ese momento. Debe disminuir a lo largo de los pasos: esa es la señal de que el aprendizaje está ocurriendo. Una pérdida que se estanca o vuelve a subir indica un problema, habitualmente una tasa de aprendizaje mal calibrada o un corpus demasiado heterogéneo.

La pérdida de validación (validation loss) mide el rendimiento sobre datos que el modelo nunca ha visto durante el entrenamiento: el archivo que apartaste durante la división. Esta es la métrica más fiable para evaluar la calidad real de tu modelo, porque es la única que el modelo no puede mejorar memorizando. Es su evolución conjunta la que proporciona el diagnóstico.

Pérdida de entrenamiento Pérdida de validación Diagnóstico
Disminuye Disminuye Todo correcto, continúa
Disminuye Aumenta Sobreajuste — reduce las épocas
Se estanca Se estanca Subajuste — aumenta la tasa de aprendizaje
Oscila Oscila Inestabilidad — reduce la tasa de aprendizaje

La segunda fila es la que más cuesta en producción: una pérdida de entrenamiento que sigue disminuyendo mientras la pérdida de validación vuelve a subir describe un modelo que memoriza tus ejemplos al pie de la letra. En el papel, todo parece mejorar; en la realidad, cada paso adicional degrada su capacidad para responder a una pregunta que nunca ha visto.

Seguimiento de eventos mediante la API

La API no envía notificaciones automáticas: debes consultar la tarea a intervalos regulares. El siguiente bucle recupera nuevos eventos, los muestra en orden cronológico evitando volver a mostrar los ya vistos y devuelve el control tan pronto como la tarea alcanza un estado terminal.

from openai import OpenAI
import time

client = OpenAI()

def monitor_job(job_id: str):
    """Monitoriza una tarea en tiempo real."""
    last_event = None

    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)

        # Recuperar nuevos eventos
        events = client.fine_tuning.jobs.list_events(
            fine_tuning_job_id=job_id,
            limit=50
        )

        for event in reversed(events.data):
            if last_event and event.id == last_event:
                continue
            print(f"[{event.created_at}] {event.message}")

        if events.data:
            last_event = events.data[0].id

        if job.status in ("succeeded", "failed", "cancelled"):
            print(f"\nTarea finalizada: {job.status}")
            if job.status == "succeeded":
                print(f"Modelo: {job.fine_tuned_model}")
            return job

        time.sleep(30)

# Uso
job = monitor_job("ftjob-xxxxxxxxxxxxxxxx")

Los eventos no solo contienen mensajes de texto: también transportan valores de pérdida en cada paso. Extraerlos te permite trazar una curva en lugar de leer líneas de registro, y es en una curva donde detectas de un vistazo un pico en la pérdida de validación.

def extract_metrics(job_id: str) -> dict:
    """Extrae las métricas de pérdida de una tarea completada."""
    events = client.fine_tuning.jobs.list_events(
        fine_tuning_job_id=job_id,
        limit=200
    )

    training_losses = []
    validation_losses = []

    for event in events.data:
        data = event.data
        if data and "train_loss" in str(data):
            training_losses.append(data)
        if data and "valid_loss" in str(data):
            validation_losses.append(data)

    return {
        "training": training_losses,
        "validation": validation_losses
    }

Puntos de control y resultados intermedios

OpenAI guarda puntos de control durante el entrenamiento. Si la tarea falla o la cancelas, a veces puedes recuperar un punto de control intermedio utilizable; en otras palabras, una ejecución interrumpida no es necesariamente una ejecución perdida. Esto también es un recurso valioso en caso de sobreajuste tardío: el punto de control tomado antes del pico de pérdida de validación puede ser mejor que el modelo final.

# Listar puntos de control para una tarea
checkpoints = client.fine_tuning.jobs.checkpoints.list(
    fine_tuning_job_id=job.id
)

for cp in checkpoints.data:
    print(f"Paso {cp.step_number}")
    print(f"  Modelo: {cp.fine_tuned_model_checkpoint}")
    if cp.metrics:
        print(f"  Pérdida de entrenamiento: {cp.metrics.train_loss:.4f}")
        if hasattr(cp.metrics, "valid_loss"):
            print(f"  Pérdida de validación: {cp.metrics.valid_loss:.4f}")

Saber cuándo detenerse

Tres señales justifican interrumpir una ejecución de entrenamiento en curso. La primera es una pérdida de validación que lleva varios pasos subiendo, no solo uno: un valor aislado es ruido, una tendencia a lo largo de cinco puntos es sobreajuste. La segunda es una pérdida de entrenamiento cercana a cero, lo que significa que el modelo está reproduciendo tus ejemplos textualmente y no tiene nada más que aprender de ellos. La tercera es más prosaica: tus pruebas no mejoran de un punto de control al siguiente y cada paso adicional solo suma a la factura.

# Si detectas un problema, cancela la tarea
client.fine_tuning.jobs.cancel(job.id)
print("Tarea cancelada. Ajusta tus datos o hiperparámetros y vuelve a lanzar.")

Un informe resumen por ejecución

Finaliza cada sesión de entrenamiento generando un registro accionable. La siguiente función reúne en una sola salida el ID de la tarea, el modelo base, las épocas utilizadas, el número de tokens entrenados y las métricas del último punto de control. Pega estos informes en tu registro de ejecuciones: dentro de un mes, te dirán por qué conservaste esta versión y no otra.

def job_report(job_id: str):
    """Genera un informe resumen para la tarea."""
    job = client.fine_tuning.jobs.retrieve(job_id)

    print("=" * 50)
    print(f"Tarea: {job.id}")
    print(f"Modelo base: {job.model}")
    print(f"Estado: {job.status}")
    print(f"Épocas: {job.hyperparameters.n_epochs}")

    if job.status == "succeeded":
        print(f"Modelo ajustado: {job.fine_tuned_model}")
        print(f"Tokens entrenados: {job.trained_tokens}")

    if job.status == "failed":
        print(f"Error: {job.error}")

    # Puntos de control
    checkpoints = client.fine_tuning.jobs.checkpoints.list(
        fine_tuning_job_id=job_id
    )
    if checkpoints.data:
        latest = checkpoints.data[0]
        print(f"Último punto de control: paso {latest.step_number}")
        if latest.metrics:
            print(f"  Pérdida de entrenamiento: {latest.metrics.train_loss:.4f}")

    print("=" * 50)

job_report("ftjob-xxxxxxxxxxxxxxxx")

Puntos clave

  • Monitoriza siempre la pérdida de validación: es tu verdadero indicador de calidad
  • Si la pérdida de validación sube, estás sufriendo sobreajuste: reduce las épocas
  • Los puntos de control te permiten recuperar un estado intermedio
  • Automatiza el seguimiento para tareas de larga duración
  • Documenta las métricas de cada ejecución para comparar tus iteraciones