Lanzar el ajuste fino mediante la API
En esta página
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 datos | Duración del entrenamiento |
|---|---|
| 50 ejemplos | Unos minutos |
| 500 ejemplos | De 15 a 30 minutos |
| 5.000 ejemplos | De 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
suffixdescriptivo 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.