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

Versionado y retroceso

Lección 16 de 16 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Por qué versionar tus modelos
  2. Nombrar versiones
  3. Mantener un registro de modelos
  4. Retroceder en segundos
  5. Archivar los datos, no solo los modelos
  6. Automatizar el pipeline completo
  7. Limpieza
  8. Puntos clave
  9. Pon a prueba tus conocimientos

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ónQué indica
v1.0Primer modelo validado en producción
v1.1Corrección de datos (mismos hiperparámetros)
v2.0Cambio de modelo base o estrategia
v2.1Ajuste 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.