Iteración: cuándo volver a hacer fine-tuning
En esta página
Actualización 2 de noviembre de 2026 — Disponibilidad del fine-tuning. OpenAI está retirando gradualmente el fine-tuning de autoservicio: desde el 7 de mayo de 2026, las organizaciones que nunca han ejecutado un trabajo de fine-tuning ya no pueden crear uno; desde el 2 de julio, debes haber utilizado 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 siguen 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.
El fine-tuning es un proceso iterativo
Es poco probable que tu primera ejecución de fine-tuning sea perfecta. La mejora surge de ciclos iterativos: analiza los errores, enriquece tus datos, vuelve a entrenar y reevalúa. Esta lección te enseña a identificar cuándo y cómo iterar de forma eficaz y, lo que es igual de importante, a reconocer situaciones en las que volver a entrenar sería inútil.
Analiza los errores antes de corregirlos
El reflejo natural tras una evaluación decepcionante es añadir ejemplos al azar, con la esperanza de que el volumen solucione el problema. Esa es la forma más rápida de quemar tu presupuesto de entrenamiento sin avanzar. Empieza clasificando cada fallo en una categoría: formato incorrecto, tono inadecuado, error factual, respuesta incompleta, respuesta fuera de tema o alucinación pura. La distribución resultante te indica dónde centrar tu esfuerzo y, a menudo, revela una sorpresa: lo que creías que era un problema de estilo resulta ser un problema de completitud.
def analyze_errors(results: list[dict]) -> dict:
"""Categoriza los errores del modelo ajustado."""
categories = {
"format": [], # Formato de respuesta incorrecto
"tone": [], # Tono inadecuado
"factual": [], # Información incorrecta
"incomplete": [], # Respuesta demasiado corta o faltan elementos
"off_topic": [], # No responde a la pregunta
"hallucination": [] # Inventa información
}
for r in results:
if r.get("score", 5) < 3:
# Clasifica el error (puede hacerse manualmente o mediante un LLM)
category = classify_error(r)
categories[category].append(r)
print("Distribución de errores:")
for cat, errors in categories.items():
if errors:
print(f" {cat}: {len(errors)} casos")
return categories
A continuación, revisa los casos dentro de la misma categoría para encontrar un denominador común. Hazte las mismas preguntas cada vez: ¿falla el modelo en un tipo específico de pregunta?, ¿se agrupan los errores en torno a ciertos temas? y ¿el problema proviene de los datos o de los hiperparámetros? Los fallos dispersos en todos los temas pero siempre de la misma naturaleza apuntan a una falta de ejemplos; los fallos concentrados en un dominio indican una brecha de cobertura; y las respuestas que se adhieren demasiado a tus ejemplos de entrenamiento independientemente de la pregunta señalan un sobreajuste que necesita corrección en el lado de las épocas (epochs).
Reconocer cuándo iterar
Ciertas señales exigen sin ambigüedad una nueva versión, y cada una requiere una respuesta diferente. Un modelo que alucina sobre un tema no se arregla mostrándole más respuestas correctas sobre ese tema, sino enseñándole a declinar educadamente cuando no lo sabe.
| Señal | Acción |
|---|---|
| Errores de formato recurrentes | Añade más ejemplos con el formato correcto |
| El modelo alucina en ciertos temas | Añade ejemplos donde decline educadamente |
| Sobreajuste detectado | Reduce las épocas, diversifica los datos |
| Nuevos casos de uso que cubrir | Añade ejemplos para estos casos |
| Comentarios negativos de usuarios específicos | Convierte los comentarios en ejemplos corregidos |
Por el contrario, varias situaciones deben disuadirte de volver a entrenar. Cuando los errores son raros y no sistemáticos, un ajuste del prompt los resuelve de forma más rápida y barata. Cuando las quejas se refieren a la latencia o los tiempos de espera, el problema reside en tu infraestructura y ningún amount de entrenamiento lo solucionará. Cuando solo has recopilado un puñado de nuevos ejemplos desde la última versión, la ganancia esperada no cubrirá el coste de la ejecución. Y cuando esté disponible un nuevo modelo base, pruébalo tal cual primero: a veces logra por sí solo, sin entrenamiento, lo que tu versión anterior tenía dificultades para ofrecer.
Enriquecer en lugar de empezar desde cero
La iteración incremental consiste en añadir ejemplos específicos a un conjunto de datos existente sin tocar el resto. Esta es la operación más frecuente y sencilla: cargas el archivo actual, concatenas los nuevos casos y reescribes todo en formato JSONL. El recuento final sirve como control: un total que no coincide con la suma esperada indica un error de lectura del archivo o líneas perdidas.
import json
def enrich_dataset(
existing_dataset: str,
new_examples: list[dict],
output: str
):
"""Añade nuevos ejemplos al conjunto de datos existente."""
# Cargar datos existentes
with open(existing_dataset, "r") as f:
existing = [json.loads(l) for l in f]
# Combinar
combined = existing + new_examples
# Guardar
with open(output, "w") as f:
for ex in combined:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print(f"Conjunto de datos enriquecido: {len(existing)} + {len(new_examples)} = {len(combined)}")
La iteración correctiva es aún más valiosa porque convierte tus fallos en materia prima. Cada error detectado en producción proporciona una pregunta real; solo necesitas escribir la respuesta que hubieras querido ver, y el par se convierte en un ejemplo de entrenamiento. Ten en cuenta que la respuesta incorrecta no va al ejemplo final: ayuda a documentar el caso y decidir si la corrección merece la pena, pero el modelo solo aprende de la versión correcta.
def error_to_example(
question: str,
bad_response: str,
good_response: str,
system_msg: str
) -> dict:
"""Transforma un error en un ejemplo de entrenamiento."""
return {
"messages": [
{"role": "system", "content": system_msg},
{"role": "user", "content": question},
{"role": "assistant", "content": good_response}
]
}
# Transformar un lote de errores
corrections = []
for error in detected_errors:
correction = error_to_example(
question=error["question"],
bad_response=error["model_response"],
good_response=error["corrected_response"],
system_msg=SYSTEM_PROMPT
)
corrections.append(correction)
Fine-tuning continuo y sus límites
Nada te impide hacer fine-tuning de un modelo que ya ha sido ajustado: simplemente pasa su ID completo en el parámetro model en lugar del nombre del modelo base. La operación es tentadora, ya que entrena solo con los nuevos datos.
# Fine-tuning a partir de un modelo ya ajustado
job_v2 = client.fine_tuning.jobs.create(
training_file=new_file.id,
model="ft:gpt-5.6-luna:org::suffix-v1:xxxxxxxx", # modelo v1 como base
suffix="my-assistant-v2"
)
Advertencia: el fine-tuning continuo acumula sesgos. Tras 2–3 iteraciones sucesivas, a menudo es mejor empezar de cero desde el modelo base con un conjunto de datos completo y enriquecido. Cada capa amplifica las peculiaridades de la anterior, incluidas aquellas que no pretendías, y el modelo acaba respondiendo con una rigidez que nadie le enseñó explícitamente.
El ciclo completo
Los siguientes pasos forman el bucle que repetirás para cada versión. Si abordas primero los errores más frecuentes, la siguiente versión mostrará ganancias medibles en tu conjunto de prueba; abordarlos fuera de orden solo produce mejoras difusas difíciles de defender ante tu equipo.
Recopilar errores
Identifica los casos en los que el modelo falla en producción o durante la evaluación.
Categorizar y priorizar
Clasifica los errores por tipo y aborda primero los más frecuentes.
Crear ejemplos correctivos
Convierte cada error en un ejemplo de entrenamiento con la respuesta correcta.
Reentrenar y reevaluar
Entrena la nueva versión y compárala con la anterior en el mismo conjunto de prueba.
Documenta cada iteración
Después de cuatro o cinco versiones, nadie recuerda qué distinguía la v2 de la v3 o por qué se abandonó la v4. Registrar sistemáticamente cada ejecución —la composición del conjunto de datos, el origen de los nuevos ejemplos, los hiperparámetros, los resultados y la decisión tomada— te proporciona esta información cuando una regresión te obliga a retroceder. Presta especial atención al origen de los nuevos ejemplos: solo eso te dirá, meses después, si la degradación provino de un lote de datos mal elegido.
iteration_log = {
"version": "v3",
"date": "2026-04-02",
"base_model": "gpt-5.6-luna",
"dataset": {
"train": 350,
"validation": 45,
"new_examples": 50,
"new_examples_source": "production errors week 12"
},
"hyperparameters": {
"n_epochs": 3,
"learning_rate_multiplier": "auto",
"batch_size": "auto"
},
"results": {
"validation_loss": 0.42,
"precision_test": 0.91,
"avg_csat": 4.3,
"improvement_vs_v2": "+5% precision, +0.2 CSAT"
},
"decision": "Deployed to production on 2026-04-03"
}
Puntos clave
- El fine-tuning es iterativo: planifica varios ciclos
- Categoriza los errores antes de corregirlos en los datos
- Convierte los comentarios de los usuarios en ejemplos de entrenamiento
- Tras 2–3 iteraciones sucesivas, reinicia desde el modelo base
- Documenta cada iteración para mantener un historial claro