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

Despliegue de un modelo ajustado

Lección 14 de 16 Actualizado el 3 de noviembre de 2026 Avanzado
En esta página
  1. Del desarrollo a producción
  2. Centraliza la configuración
  3. Resiste incidentes
  4. Registra lo importante
  5. Antes de abrir las compuertas
  6. Puntos clave

Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI: temperature y top_p solo se aceptan con un esfuerzo de razonamiento de none, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificar reasoning={"effort": "none"} (API Responses) o reasoning_effort="none" (Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.

Actualización del 2 de noviembre de 2026 — Disponibilidad del ajuste fino. El ajuste fino autoservicio de OpenAI está siendo eliminado gradualmente: desde el 7 de mayo de 2026, las organizaciones que nunca han realizado un ajuste fino ya no pueden crear trabajos; desde el 2 de julio, es necesario 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 permanecen 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.

Del desarrollo a producción

Tu modelo ajustado ha sido evaluado y aprobado. Es hora de desplegarlo en producción. Esta lección cubre las mejores prácticas para un despliegue fiable, seguro y mantenible: todo lo que separa un modelo ejecutándose en tu portátil de un servicio al que tus usuarios pueden acceder continuamente sin que tú tengas que estar de guardia.

Empecemos por lo básico: un modelo ajustado funciona exactamente igual que cualquier otro modelo de OpenAI. La única diferencia es el nombre del modelo, que se convierte en un identificador largo que incluye tu organización, tu sufijo y un ID de trabajo. No hay parámetros extra ni endpoints especiales.

from openai import OpenAI

client = OpenAI()

# El modelo ajustado tiene un identificador único
MODELE_PRODUCTION = "ft:gpt-5.6-luna:votre-org::mon-assistant-v3:abc12345"

response = client.responses.create(
    model=MODELE_PRODUCTION,
    input="Hello, I have an issue with my order #12345."
)

print(response.output_text)

Centraliza la configuración

Este identificador tiene una peculiaridad que debe regir toda tu arquitectura: cambia con cada nueva versión de tu modelo. Hardcodearlo en toda tu aplicación obliga a un redespliegue completo ante la más mínima actualización, y provoca una búsqueda tediosa el día que aparezca en tres lugares diferentes. Colócalo en una variable de entorno, con el modelo base como valor de respaldo: tu aplicación arrancará incluso si la variable no está definida, evitando un incidente silencioso del servicio un domingo por la noche.

import os

class Config:
    """Configuración centralizada del modelo."""

    # Variable de entorno para el modelo de producción
    MODEL_ID = os.environ.get(
        "OPENAI_FT_MODEL",
        "gpt-5.6-luna"  # respaldo al modelo base
    )

    # Prompt de sistema (puede estar vacío si se integra en el ajuste fino)
    SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")

    # Parámetros de generación
    MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
    TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))

La misma lógica se aplica a las propias llamadas. En lugar de dispersar llamadas a client.responses.create por toda tu lógica de negocio, encapsúlalas en un único servicio. Ganarás un punto de control obligatorio donde podrás conectar más tarde registros, métricas y mecanismos de respaldo sin tener que reabrir veinte archivos. Observa cómo el servicio de abajo compone un contexto opcional con la pregunta y cómo captura cualquier excepción para redirigirla al modelo base.

from openai import OpenAI

class AssistantService:
    """Servicio que encapsula las llamadas al modelo ajustado."""

    def __init__(self):
        self.client = OpenAI()
        self.model = Config.MODEL_ID

    def repondre(self, question: str, contexte: str = "") -> str:
        """Genera una respuesta."""
        input_msg = question
        if contexte:
            input_msg = f"Context: {contexte}\n\nQuestion: {question}"

        try:
            response = self.client.responses.create(
                model=self.model,
                reasoning={"effort": "none"},  # temperature requiere effort none
                input=input_msg,
                max_output_tokens=Config.MAX_TOKENS,
                temperature=Config.TEMPERATURE
            )
            return response.output_text

        except Exception as e:
            # Respaldo al modelo base en caso de error
            return self._fallback(input_msg, str(e))

    def _fallback(self, input_msg: str, erreur: str) -> str:
        """Respaldo al modelo base."""
        print(f"Fallback activated: {erreur}")
        response = self.client.responses.create(
            model="gpt-5.6-luna",
            instructions=Config.SYSTEM_PROMPT,
            input=input_msg
        )
        return response.output_text

Resiste incidentes

Una respuesta degradada es mejor que ninguna respuesta. Si tu modelo ajustado no está disponible temporalmente, es preferible cambiar al modelo base —con el prompt de sistema que conservaste precisamente para este caso— que mostrar un error al usuario. La siguiente función encadena dos mecanismos complementarios: primero, tres intentos en el modelo principal, espaciados por un retraso que se duplica con cada fallo para evitar empeorar una sobrecarga temporal; luego, solo si todo falla, una llamada al modelo de respaldo. Mantén la bandera fallback devuelta en el resultado, ya que es el único rastro utilizable de la frecuencia con la que se activa este mecanismo.

import time

def appel_resilient(
    client: OpenAI,
    modele_principal: str,
    modele_fallback: str,
    input_msg: str,
    max_retries: int = 3
) -> dict:
    """Llamada resiliente con reintentos y respaldo."""

    for tentative in range(max_retries):
        try:
            response = client.responses.create(
                model=modele_principal,
                input=input_msg,
                timeout=30
            )
            return {
                "reponse": response.output_text,
                "modele_utilise": modele_principal,
                "fallback": False
            }
        except Exception as e:
            print(f"Attempt {tentative + 1} failed: {e}")
            if tentative < max_retries - 1:
                time.sleep(2 ** tentative)  # retroceso exponencial

    # Respaldo
    try:
        response = client.responses.create(
            model=modele_fallback,
            input=input_msg
        )
        return {
            "reponse": response.output_text,
            "modele_utilise": modele_fallback,
            "fallback": True
        }
    except Exception as e:
        return {"erreur": str(e), "fallback": True}

La limitación de tasa merece un tratamiento separado porque no es una interrupción, sino una regulación: los modelos ajustados comparten los mismos límites de tasa que los modelos base. Un RateLimitError simplemente te pide que esperes, y la espera progresiva de abajo es suficiente para absorber un pico. Sin embargo, si el bucle alcanza su techo, el problema ya no es coyuntural y necesitas revisar tu cuota.

from openai import RateLimitError
import time

def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
    """Gestiona la limitación de tasa con espera progresiva."""
    wait = 1
    while wait <= max_wait:
        try:
            return client.responses.create(
                model=modele,
                input=input_msg
            )
        except RateLimitError:
            print(f"Rate limit reached, waiting {wait}s...")
            time.sleep(wait)
            wait *= 2

    raise Exception("Persistent rate limit — check your quotas")

Registra lo importante

El registro estructurado convierte incidentes opacos en diagnósticos rápidos. Para cada llamada, registra el modelo utilizado realmente, el volumen de entrada y salida, la latencia y la bandera de respaldo. Esta información es suficiente para responder a las preguntas que surgen durante un incidente: ¿desde cuándo se está desviando la latencia?, ¿se debe el aumento de coste al tráfico o a respuestas más largas?, ¿a cuántos usuarios se ha atendido realmente con el modelo base?

import logging
import datetime

logger = logging.getLogger("fine_tuning_prod")

def log_appel(
    modele: str,
    input_msg: str,
    output: str,
    latence_ms: float,
    fallback: bool
):
    """Registro estructurado para cada llamada en producción."""
    logger.info(
        "appel_modele",
        extra={
            "modele": modele,
            "input_tokens": len(input_msg.split()),
            "output_tokens": len(output.split()),
            "latence_ms": latence_ms,
            "fallback": fallback,
            "timestamp": datetime.datetime.now().isoformat()
        }
    )

En cuanto a la configuración, todo va a un archivo de entorno que nunca debe entrar en tu repositorio: contiene tu clave de API, y una clave publicada es una clave comprometida.

# .env (no hacer commit)
OPENAI_API_KEY=sk-...
OPENAI_FT_MODEL=ft:gpt-5.6-luna:org::suffix:abc12345
OPENAI_FT_MODEL_FALLBACK=gpt-5.6-luna
SYSTEM_PROMPT="You are a professional customer support assistant."
MAX_TOKENS=1024
TEMPERATURE=0.7

Antes de abrir las compuertas

Antes de exponer el servicio a tus usuarios, repasa punto por punto las comprobaciones de esta lección. El modelo debe haber sido evaluado y aprobado frente al umbral que definiste de antemano; su nombre debe vivir en una variable de entorno y en ningún sitio hardcodeado; debe haber un mecanismo de respaldo implementado. Estos tres puntos condicionan todo lo demás, porque sin ellos estás poniendo en línea un modelo cuya calidad medida, dirección exacta y comportamiento cuando la API responde mal son desconocidos.

A continuación, verifica la instrumentación. El registro debe estar activado y registrar como mínimo el modelo utilizado, la latencia y los tokens; la limitación de tasa debe gestionarse, no sufrirse; las alertas deben configurarse sobre la tasa de error y la latencia P95, de lo contrario tu primer usuario insatisfecho hará el papel de sonda. Finalmente, el rollback debe estar documentado y ser comprobable: un rollback que nunca se ha ejecutado realmente sigue siendo una intención, no un mecanismo.

Puntos clave

  • Usa variables de entorno para el nombre del modelo
  • Implementa siempre un respaldo al modelo base
  • Registra cada llamada con el modelo utilizado y la latencia
  • Gestiona la limitación de tasa con retroceso exponencial
  • Prueba tu mecanismo de respaldo antes de desplegar