Versionado y retroceso
En esta página
Actualización 2 de noviembre de 2026 — Disponibilidad del ajuste fino. El servicio de ajuste fino de autoservicio de OpenAI se está eliminando 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, debes 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 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.
Por qué versionar tus modelos
En producción, iterarás sobre tu modelo ajustado: nuevos datos, hiperparámetros ajustados, nuevo modelo base. Sin un sistema de versionado riguroso, perderás la trazabilidad y la capacidad de revertir cambios en caso de regresión. El escenario es siempre el mismo: un lunes por la mañana, los comentarios de los usuarios empeoran, nadie sabe qué modelo se está ejecutando realmente ni qué datos lo produjeron, y el equipo pasa el día reconstruyendo información que un archivo de pocas líneas habría preservado.
Nombrar versiones
El parámetro suffix de la tarea de ajuste fino es tu primera herramienta de trazabilidad: la cadena que coloques allí termina en el ID final del modelo y permanece legible en todas partes: en tus registros, tu configuración y tu consola. Adopta una convención y cúmplela.
# Convención: {nombre}-v{versión_mayor}.{versión_menor}
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
model="gpt-5.6-luna",
suffix="support-client-v2.1"
)
El número en sí debe aportar información, no solo contar intentos. Una versión mayor cambia cuando cambia la naturaleza del modelo; una versión menor, cuando mejoras sin romper nada. Concretamente, una corrección de datos aplicada con los mismos hiperparámetros se mantiene en la misma versión mayor, mientras que un cambio de modelo base requiere iniciar una nueva.
| Versión | Qué indica |
|---|---|
| v1.0 | Primer modelo validado en producción |
| v1.1 | Corrección de datos (mismos hiperparámetros) |
| v2.0 | Cambio de modelo base o estrategia |
| v2.1 | Ajuste de hiperparámetros |
Mantener un registro de modelos
El nombre por sí solo no basta: no dice nada sobre qué había en el conjunto de datos, los resultados obtenidos o por qué se promovió esta versión. Un registro centralizado mantiene estos metadatos junto al ID técnico y se convierte en la única fuente de verdad de tu equipo. La clase siguiente guarda lo esencial en un archivo JSON: registra un modelo candidato, promueve uno a producción marcando el anterior como retirado, devuelve el ID actualmente activo y muestra el historial. Tómate el tiempo de rellenar el campo notes: una sola frase sobre qué ha cambiado desde la versión anterior te ahorrará medio día de arqueología más adelante.
import json
import datetime
class ModelRegistry:
"""Registro de modelos ajustados."""
def __init__(self, path: str = "model_registry.json"):
self.path = path
try:
with open(path, "r") as f:
self.registry = json.load(f)
except FileNotFoundError:
self.registry = {"models": [], "production": None}
def record(
self,
version: str,
model_id: str,
job_id: str,
dataset_info: dict,
hyperparams: dict,
metrics: dict,
notes: str = ""
):
"""Registra un nuevo modelo en el registro."""
entry = {
"version": version,
"model_id": model_id,
"job_id": job_id,
"date": datetime.datetime.now().isoformat(),
"dataset": dataset_info,
"hyperparameters": hyperparams,
"metrics": metrics,
"notes": notes,
"status": "candidate"
}
self.registry["models"].append(entry)
self._save()
print(f"Modelo {version} registrado: {model_id}")
def promote(self, version: str):
"""Promueve un modelo a producción."""
old = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
m["status"] = "production"
self.registry["production"] = version
break
if old:
for m in self.registry["models"]:
if m["version"] == old:
m["status"] = "retired"
self._save()
print(f"Producción: {old} -> {version}")
def rollback(self, version: str):
"""Retrocede a una versión anterior."""
self.promote(version)
print(f"Retroceso realizado a {version}")
def production_model(self) -> str:
"""Devuelve el ID del modelo en producción."""
version = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
return m["model_id"]
return None
def history(self):
"""Muestra el historial del modelo."""
print(f"{'Versión':<12} {'Estado':<12} {'Fecha':<12} {'Pérdida Val':<10}")
print("-" * 50)
for m in self.registry["models"]:
date = m["date"][:10]
loss = m["metrics"].get("validation_loss", "N/A")
print(f"{m['version']:<12} {m['status']:<12} {date:<12} {loss}")
def _save(self):
with open(self.path, "w") as f:
json.dump(self.registry, f, indent=2, ensure_ascii=False)
En la práctica, el ciclo de vida de una versión se reduce a tres llamadas: registras el modelo que sale del entrenamiento con sus números, lo promueves cuando la evaluación lo valida y reviertes a la versión anterior si la producción contradice la evaluación. Esta última línea debería ser tan trivial de escribir como las dos primeras.
registry = ModelRegistry()
# Registrar un nuevo modelo
registry.record(
version="v2.1",
model_id="ft:gpt-5.6-luna:org::support-v2.1:abc123",
job_id="ftjob-xyz789",
dataset_info={"train": 350, "validation": 45},
hyperparams={"n_epochs": 3, "lr": "auto"},
metrics={"validation_loss": 0.38, "precision_test": 0.93},
notes="Añadidos 50 ejemplos de corrección para reembolsos"
)
# Promover a producción
registry.promote("v2.1")
# En caso de problemas, retroceder
registry.rollback("v2.0")
Retroceder en segundos
Un retroceso solo tiene valor si es rápido y no requiere pensar. Dado que tu aplicación lee el nombre del modelo desde una variable de entorno, cambiar de versión significa cambiar esa variable y actualizar el registro: sin redespliegue de código, sin recompilación. La función quick_rollback va más allá al omitir por completo la elección humana: recupera la última versión estable disponible y, si no existe ninguna, recurre al modelo base. Esta última rama es tu red de seguridad absoluta; actívala voluntariamente una vez en un entorno de pruebas, mientras las apuestas son cero.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Despliega un modelo actualizando la variable de entorno."""
model_id = None
for m in registry.registry["models"]:
if m["version"] == version:
model_id = m["model_id"]
break
if not model_id:
raise ValueError(f"Versión {version} no encontrada")
# Actualizar configuración
os.environ["OPENAI_FT_MODEL"] = model_id
registry.promote(version)
print(f"Modelo desplegado: {version} ({model_id})")
return model_id
def quick_rollback(registry: ModelRegistry):
"""Retrocede a la última versión estable."""
production = registry.registry["production"]
versions = [
m for m in registry.registry["models"]
if m["version"] != production and m["status"] != "retired"
]
if not versions:
# Recurrir al modelo base
os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
print("Retroceso al modelo base")
return
last_stable = versions[-1]
deploy_model(last_stable["version"], registry)
Archivar los datos, no solo los modelos
Versionar un modelo sin versionar lo que lo produjo solo te lleva hasta la mitad del camino. El día que quieras entender por qué la v2.1 mantuvo mejor el tono que la v2.2, necesitarás los tres archivos exactos usados para entrenarla, incluido el conjunto de prueba; sin ello, ninguna comparación posterior será justa. Archívalos en una carpeta con el número de versión, en el mismo momento en que registras el modelo.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Archiva los datos de entrenamiento para una versión dada."""
folder = f"{archive_folder}/{version}"
os.makedirs(folder, exist_ok=True)
for file in files:
shutil.copy2(file, folder)
print(f"Datos archivados en {folder}")
archive_dataset(
"v2.1",
["train.jsonl", "validation.jsonl", "test.jsonl"],
"archives/datasets"
)
Automatizar el pipeline completo
Estos pasos, ejecutados a mano, eventualmente se omiten, especialmente el archivado, que llega al final y no bloquea nada. Agrúpalos en un único script que encadene la subida de archivos, el lanzamiento de la tarea, la espera hasta su finalización, el registro en el modelo y, finalmente, el archivado de los datos. El bucle de espera consulta la tarea cada treinta segundos y se detiene en un estado terminal; en caso de fallo, la función retorna inmediatamente en lugar de continuar con un modelo inexistente.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Pipeline completo: subida, entrenamiento, evaluación, registro."""
client = OpenAI()
registry = ModelRegistry()
# 1. Subida
print("Subiendo datos...")
train = client.files.create(file=open(training_file, "rb"), purpose="fine-tune")
val = client.files.create(file=open(validation_file, "rb"), purpose="fine-tune")
# 2. Entrenamiento
print("Lanzando ajuste fino...")
params = {"training_file": train.id, "validation_file": val.id,
"model": base_model, "suffix": version}
if hyperparams:
params["hyperparameters"] = hyperparams
job = client.fine_tuning.jobs.create(**params)
# 3. Esperar finalización
import time
while True:
job = client.fine_tuning.jobs.retrieve(job.id)
if job.status in ("succeeded", "failed"):
break
time.sleep(30)
if job.status == "failed":
print(f"Fallo: {job.error}")
return None
# 4. Registro
registry.record(
version=version,
model_id=job.fine_tuned_model,
job_id=job.id,
dataset_info={"train": training_file, "validation": validation_file},
hyperparams=hyperparams or {},
metrics={"trained_tokens": job.trained_tokens}
)
# 5. Archivar datos
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Pipeline completado: {job.fine_tuned_model}")
return job.fine_tuned_model
Limpieza
Los modelos ajustados se almacenan en OpenAI y pueden eliminarse cuando ya no los necesitas. Después de una docena de iteraciones, la lista se vuelve ilegible y la ordenación manual peligrosa. La limpieza automática siguiente mantiene las tres versiones más recientes y nunca toca la que se está ejecutando en producción. Evita ser demasiado agresivo: es precisamente la penúltima versión, a menudo considerada inútil, la que te salvará durante un retroceso.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Elimina modelos antiguos manteniendo los últimos N."""
models = registry.registry["models"]
production = registry.registry["production"]
candidates = [
m for m in models
if m["version"] != production
]
to_delete = candidates[:-keep] if len(candidates) > keep else []
for m in to_delete:
try:
client.models.delete(m["model_id"])
print(f"Eliminado: {m['version']} ({m['model_id']})")
except Exception as e:
print(f"Error al eliminar {m['version']}: {e}")
Puntos clave
- Usa sufijos versionados para identificar cada modelo
- Mantén un registro centralizado con métricas y metadatos
- Implementa un mecanismo de retroceso rápido
- Archiva los datos de entrenamiento con cada versión
- Automatiza el pipeline y limpia regularmente los modelos antiguos: menos errores humanos, menos costes innecesarios
Pon a prueba tus conocimientos
Antes de versionar tus modelos, valida el ciclo completo de ajuste fino.
1. ¿Cuándo es el ajuste fino la herramienta adecuada y cuándo no?
Respuesta: Bueno para anclar un estilo, formato o comportamiento recurrente que el prompting no logra de forma fiable; malo para inyectar conocimiento nuevo, ese es el papel de RAG.
2. ¿Qué hace que un conjunto de datos de entrenamiento sea de alta calidad?
Respuesta: Ejemplos limpios, consistentes y representativos en formato JSONL conversacional: unos pocos cientos de ejemplos excelentes vencen a miles ruidosos.
3. ¿Qué aporta DPO en comparación con el ajuste fino supervisado?
Respuesta: Aprendizaje por preferencias: proporcionas pares de respuestas preferidas/rechazadas y el modelo aprende «mejor» en lugar de una simple imitación; útil para el tono y los matices finos.
4. ¿Cómo validas un modelo ajustado?
Respuesta: Comparándolo con el modelo base en un conjunto de evaluación mantenido separado del entrenamiento y luego mediante pruebas A/B en métricas de negocio, nunca solo por impresión.
5. ¿Por qué versionar y planificar el retroceso?
Respuesta: Cada ajuste fino produce un modelo fechado: en caso de regresión en producción, vuelves inmediatamente a la versión anterior; el modelo se gestiona como el código.
Datos limpios, evaluación honesta, versiones controladas: el ajuste fino es una disciplina de ingeniería; este curso te ha dado el ciclo completo.