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

Lanzar el ajuste fino mediante la API

Lección 5 de 16 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Resumen del proceso
  2. Instalación y configuración del SDK
  3. Subida de archivos
  4. Creación del trabajo de ajuste fino
  5. Seguimiento del progreso
  6. Uso del modelo ajustado fino
  7. Gestión de tus trabajos
  8. Costes y duración
  9. 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 han ejecutado un trabajo de ajuste fino ya no pueden crear uno; desde el 2 de julio, es necesario haber utilizado un modelo ajustado fino 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.

Resumen del proceso

Tus datos están listos, validados y divididos en conjuntos de entrenamiento y validación. El paso real de entrenamiento se reduce a tres movimientos: subir tu archivo de datos, crear un trabajo de ajuste fino y esperar a que finalice el entrenamiento. Todo se realiza a través del SDK oficial de Python, y verás que el código cabe en unas treinta líneas; la mayor parte del trabajo ya se ha realizado en fases anteriores.

Instalación y configuración del SDK

El cliente se instancia sin argumentos: lee automáticamente la variable de entorno OPENAI_API_KEY.

# Instalación
# pip install openai

from openai import OpenAI

# El cliente utiliza automáticamente la variable de entorno OPENAI_API_KEY
client = OpenAI()

Asegúrate de que esta variable esté definida antes de ejecutar el script; de lo contrario, la instancia fallará en la primera solicitud. En producción, nunca hardcodees tu clave en el código: una clave escrita en texto plano acaba en el historial de Git, y eliminarla después del hecho es mucho más costoso que leerla desde el entorno desde el primer día.

Subida de archivos

La subida utiliza purpose="fine-tune", lo que indica a OpenAI que el archivo está destinado al entrenamiento y activa las comprobaciones de formato correspondientes. Sube el archivo de validación de inmediato: técnicamente es opcional, pero sin él el entrenamiento funciona a ciegas, ya que ninguna pérdida de validación señalará el sobreajuste mientras se ejecuta el trabajo.

# Subir archivo de entrenamiento
training_file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"ID de archivo: {training_file.id}")
print(f"Estado: {training_file.status}")

# Opcional: subir archivo de validación
validation_file = client.files.create(
    file=open("validation_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"ID de validación: {validation_file.id}")

El archivo pasa por una fase de procesamiento en el lado de OpenAI. Espera hasta que el estado sea processed antes de lanzar el trabajo: un trabajo creado sobre un archivo que aún se está procesando fallará, y perderás unos minutos buscando una causa inexistente en tu JSONL.

Creación del trabajo de ajuste fino

job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    validation_file=validation_file.id,  # opcional pero recomendado
    model="gpt-5.6-luna",  # o "gpt-5.6-luna"
    suffix="my-assistant-v1"  # sufijo para identificar tu modelo
)

print(f"ID de trabajo: {job.id}")
print(f"Estado: {job.status}")
print(f"Modelo base: {job.model}")

El parámetro suffix se añade al nombre de tu modelo ajustado fino: con "my-assistant-v1", el modelo resultante se llamará ft:gpt-5.6-luna:your-org::my-assistant-v1:xxxxxxxx. Acostúmbrate a incluir ahí el caso de uso y un número de versión. El día que coexistan tres modelos en tu cuenta, eso será lo único que te permitirá saber qué hace cada uno sin abrir la consola.

Seguimiento del progreso

Un trabajo pasa por varios estados en secuencia, y retrieve te ofrece el estado actual en cualquier momento.

# Obtener estado del trabajo
job = client.fine_tuning.jobs.retrieve(job.id)
print(f"Estado: {job.status}")
# Estados posibles: validating_files, queued, running, succeeded, failed, cancelled

El estado por sí solo resulta lacónico. Los eventos, en cambio, cuentan la historia: validación de archivos, inicio, progreso paso a paso y finalización.

# Ver eventos del trabajo
events = client.fine_tuning.jobs.list_events(
    fine_tuning_job_id=job.id,
    limit=20
)

for event in events.data:
    print(f"[{event.created_at}] {event.message}")

En lugar de llamar a retrieve manualmente cada cinco minutos, envuelve la espera en un bucle que devuelva el control tan pronto como el trabajo alcance un estado terminal. Ten en cuenta que los tres casos de salida se gestionan por separado: un trabajo cancelado no es un trabajo fallido, y querrás distinguirlos en tus registros.

import time

def track_job(client: OpenAI, job_id: str, interval: int = 30):
    """Sigue un trabajo de ajuste fino hasta su finalización."""
    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)
        print(f"Estado: {job.status}")

        if job.status == "succeeded":
            print(f"Modelo ajustado fino: {job.fine_tuned_model}")
            return job

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

        if job.status == "cancelled":
            print("Trabajo cancelado.")
            return job

        time.sleep(interval)

# Uso
final_job = track_job(client, job.id)

Uso del modelo ajustado fino

Una vez que el trabajo se completa con éxito, tu modelo se llama exactamente igual que un modelo estándar. Solo cambia el valor pasado a model, lo que significa que cambiar a tu modelo personalizado se reduce, en una aplicación existente, a modificar una variable de configuración.

response = client.responses.create(
    model=final_job.fine_tuned_model,  # p. ej., "ft:gpt-5.6-luna:org::suffix:xxxxxxxx"
    input="Hola, tengo un problema con mi pedido."
)

print(response.output_text)

Gestión de tus trabajos

Dos llamadas son suficientes para administrarlo todo: listar lo que existe e interrumpir lo que se está ejecutando. La cancelación es útil tan pronto como el seguimiento muestra que el entrenamiento se desvía: no tiene sentido pagar por tokens de un trabajo del que ya sabes que producirá un modelo deficiente.

# Listar todos tus trabajos de ajuste fino
jobs = client.fine_tuning.jobs.list(limit=10)
for j in jobs.data:
    print(f"{j.id} | {j.status} | {j.model} | {j.fine_tuned_model}")

# Cancelar un trabajo en ejecución
client.fine_tuning.jobs.cancel(job.id)

Costes y duración

El entrenamiento se factura por el número de tokens procesados. La duración, por otro lado, depende del tamaño de tus datos y del número de épocas.

Tamaño del conjunto de datosDuración del entrenamiento
50 ejemplosUnos minutos
500 ejemplosDe 15 a 30 minutos
5.000 ejemplosDe 1 a 2 horas

Estos órdenes de magnitud te ayudan principalmente a dimensionar tu bucle de trabajo: con unos minutos por ejecución, iteras en la misma sesión; con dos horas, planificas. Los precios exactos varían según el modelo elegido; consulta la página de precios de OpenAI para conocer las tarifas actuales.

Puntos clave

  • El flujo de trabajo es: subir archivo, crear trabajo, esperar y usar el modelo.
  • Añade un suffix descriptivo para identificar fácilmente tus modelos.
  • Utiliza siempre un archivo de validación para evaluar la calidad.
  • El modelo ajustado fino se usa exactamente igual que el modelo base a través de la API.
  • Conserva los ID de tus trabajos y modelos; los necesitarás para el control de versiones.