Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Implementar um modelo ajustado

Aula 14 de 16 Atualizada a 3 de novembro de 2026 Avancado
Nesta página
  1. Do desenvolvimento para a produção
  2. Centralizar a configuração
  3. Resistir a incidentes
  4. Registar o que importa
  5. Antes de abrir as comportas
  6. Pontos-chave

Lição atualizada em 3 de novembro de 2026 com base na documentação da OpenAI: temperature e top_p só são aceites com um esforço de raciocínio de none, enquanto os modelos GPT-5.6 raciocinam por predefinição (medium). As chamadas que definem estes parâmetros devem, portanto, especificar reasoning={"effort": "none"} (API Responses) ou reasoning_effort="none" (Chat Completions). Fontes: Using GPT-6 · GPT-5.6 Terra.

Atualização de 2 de novembro de 2026 — Disponibilidade do ajuste fino. O ajuste fino de autosserviço da OpenAI está a ser descontinuado: desde 7 de maio de 2026, as organizações que nunca realizaram ajuste fino não podem criar novas tarefas; desde 2 de julho, é necessário ter utilizado um modelo ajustado nos últimos 60 dias; e a partir de 6 de janeiro de 2027, nenhum cliente poderá lançar novas tarefas. Os modelos já treinados permanecem utilizáveis até que o seu modelo base seja desativado. Este curso mantém a sua utilidade para compreender e aproveitar um modelo existente; para novos projetos, priorize a engenharia de prompts, RAG e avaliações.

Do desenvolvimento para a produção

O seu modelo ajustado foi avaliado e aprovado. É altura de o implementar em produção. Esta lição abrange as melhores práticas para uma implementação fiável, segura e sustentável — tudo o que separa um modelo a funcionar no seu portátil de um serviço que os seus utilizadores podem aceder continuamente sem que precise de estar de guarda.

Comecemos pelo básico: um modelo ajustado funciona exatamente como qualquer outro modelo da OpenAI. A única diferença é o nome do modelo, que se torna num identificador longo que inclui a sua organização, o seu sufixo e um ID de tarefa. Não há parâmetros extra, nem endpoints especiais.

from openai import OpenAI

client = OpenAI()

# O modelo ajustado tem um 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)

Centralizar a configuração

Este identificador tem uma particularidade que deve governar toda a sua arquitetura: muda com cada nova versão do seu modelo. Codificá-lo diretamente em toda a sua aplicação obriga a uma reimplementação completa para a mais pequena atualização e a uma pesquisa tediosa no dia em que aparecer em três locais diferentes. Coloque-o numa variável de ambiente, com o modelo base como valor de fallback: a sua aplicação iniciará mesmo que a variável não esteja definida, evitando um incidente de serviço silencioso num domingo à noite.

import os

class Config:
    """Configuração centralizada do modelo."""

    # Variável de ambiente para o modelo de produção
    MODEL_ID = os.environ.get(
        "OPENAI_FT_MODEL",
        "gpt-5.6-luna"  # fallback para o modelo base
    )

    # Prompt do sistema (pode estar vazio se integrado no ajuste fino)
    SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")

    # Parâmetros de geração
    MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
    TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))

A mesma lógica aplica-se às próprias chamadas. Em vez de dispersar chamadas client.responses.create por toda a sua lógica de negócio, encapsule-as num único serviço. Ganha um ponto de controlo obrigatório onde poderá mais tarde integrar registo, métricas e fallback sem precisar de reabrir vinte ficheiros. Note como o serviço abaixo compõe um contexto opcional com a pergunta e como captura qualquer exceção para a redirecionar para o modelo base.

from openai import OpenAI

class AssistantService:
    """Serviço que encapsula as chamadas ao modelo ajustado."""

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

    def repondre(self, question: str, contexte: str = "") -> str:
        """Gera uma resposta."""
        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 requer effort none
                input=input_msg,
                max_output_tokens=Config.MAX_TOKENS,
                temperature=Config.TEMPERATURE
            )
            return response.output_text

        except Exception as e:
            # Fallback para o modelo base em caso de erro
            return self._fallback(input_msg, str(e))

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

Resistir a incidentes

Uma resposta degradada é preferível a nenhuma resposta. Se o seu modelo ajustado estiver temporariamente indisponível, é melhor mudar para o modelo base — com o prompt do sistema que manteve precisamente para este caso — do que apresentar um erro ao utilizador. A função seguinte encadeia dois mecanismos complementares: primeiro, três tentativas no modelo primário, espaçadas por um atraso que duplica a cada falha para evitar agravar uma sobrecarga temporária; depois, apenas se tudo falhar, uma chamada ao modelo de fallback. Mantenha a flag fallback devolvida no resultado, pois é o único rasto utilizável da frequência com que este mecanismo é realmente acionado.

import time

def appel_resilient(
    client: OpenAI,
    modele_principal: str,
    modele_fallback: str,
    input_msg: str,
    max_retries: int = 3
) -> dict:
    """Chamada resiliente com repetição e fallback."""

    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"Tentativa {tentative + 1} falhou: {e}")
            if tentative < max_retries - 1:
                time.sleep(2 ** tentative)  # backoff exponencial

    # Fallback
    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}

O rate limiting merece um tratamento separado porque não é uma indisponibilidade, mas sim uma regulação: os modelos ajustados partilham os mesmos limites de taxa que os modelos base. Um RateLimitError pede simplesmente que espere, e a espera progressiva abaixo é suficiente para absorver um pico. Se o loop atingir o seu teto, no entanto, o problema deixa de ser conjuntural e precisa de rever a sua quota.

from openai import RateLimitError
import time

def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
    """Gera o rate limiting com espera progressiva."""
    wait = 1
    while wait <= max_wait:
        try:
            return client.responses.create(
                model=modele,
                input=input_msg
            )
        except RateLimitError:
            print(f"Limite de taxa atingido, a aguardar {wait}s...")
            time.sleep(wait)
            wait *= 2

    raise Exception("Limite de taxa persistente — verifique as suas quotas")

Registar o que importa

O registo estruturado transforma incidentes opacos em diagnósticos rápidos. Para cada chamada, registe o modelo realmente utilizado, o volume de entrada e saída, a latência e a flag de fallback. Esta informação é suficiente para responder às perguntas que surgem durante um incidente: há quanto tempo é que a latência está a desviar, o aumento de custos deve-se ao tráfego ou a respostas mais longas, e quantos utilizadores foram realmente servidos pelo 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
):
    """Registo estruturado para cada chamada de produção."""
    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()
        }
    )

No lado da configuração, tudo vai para um ficheiro de ambiente que nunca deve entrar no seu repositório: contém a sua chave de API, e uma chave publicada é uma chave comprometida.

# .env (não fazer 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 as comportas

Antes de expor o serviço aos seus utilizadores, percorra ponto por ponto as verificações desta lição. O modelo deve ter sido avaliado e aprovado face ao limiar que definiu antecipadamente; o seu nome deve residir numa variável de ambiente e em lado nenhum codificado diretamente; um mecanismo de fallback deve estar no lugar. Estes três pontos condicionam todo o resto, porque sem eles está a colocar online um modelo cuja qualidade medida, endereço exato e comportamento quando a API responde mal são desconhecidos.

De seguida, verifique a instrumentação. O registo deve estar ativado e registar, no mínimo, o modelo utilizado, a latência e os tokens; o rate limiting deve ser gerido em vez de sofrido; os alertas devem ser configurados para a taxa de erro e a latência P95, caso contrário o seu primeiro utilizador insatisfeito fará o papel de sonda. Finalmente, o rollback deve estar documentado e testável — um rollback nunca realmente executado permanece uma intenção, não um mecanismo.

Pontos-chave

  • Utilize variáveis de ambiente para o nome do modelo
  • Implemente sempre um fallback para o modelo base
  • Registe cada chamada com o modelo utilizado e a latência
  • Gere o rate limiting com backoff exponencial
  • Teste o seu mecanismo de fallback antes da implementação