Implementar um modelo ajustado
Nesta página
Lição atualizada em 3 de novembro de 2026 com base na documentação da OpenAI:
temperatureetop_psó são aceites com um esforço de raciocínio denone, enquanto os modelos GPT-5.6 raciocinam por predefinição (medium). As chamadas que definem estes parâmetros devem, portanto, especificarreasoning={"effort": "none"}(API Responses) oureasoning_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