Custos e Otimização
Nesta página
Atualização de 2 de novembro de 2026 — Disponibilidade do fine-tuning. O fine-tuning de autosserviço da OpenAI está a ser descontinuado: desde 7 de maio de 2026, as organizações que nunca o utilizaram já não podem criar 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, a RAG e as avaliações.
Compreender a Estrutura de Custos
O fine-tuning da OpenAI envolve dois tipos de custos: um custo de treino único e um custo recorrente de inferência. Compreender e otimizar estes custos é essencial para uma implementação rentável. A distinção não é apenas contabilística: o primeiro é uma decisão única tomada antes de lançar a tarefa e não se altera; o segundo acompanha-o todos os meses e cresce com o seu tráfego. Uma equipa que regateie os custos de treino enquanto deixa um prompt de mil tokens correr em cinco mil pedidos diários está a travar a batalha errada.
O Custo de Treino
O treino é faturado por token processado, e esse número depende diretamente de duas variáveis que controla: o tamanho do seu conjunto de dados e o número de passagens sobre o mesmo.
Custo de treino = total_tokens × number_epochs × price_per_training_token
Esta fórmula permite-lhe estimar a fatura antes de lançar qualquer coisa. A função seguinte analisa o ficheiro JSONL e aproxima a contagem de tokens com base no comprimento da mensagem — a estimativa de um token por quatro caracteres em português é grosseira, mas é suficiente para distinguir uma tarefa de alguns dólares de uma que custe várias centenas. Habitue-se a executar isto sistematicamente: um erro de preparação que triplique o seu conjunto de dados aparecerá imediatamente no resultado.
import json
def estimate_training_cost(
jsonl_file: str,
n_epochs: int,
price_per_million_tokens: float
) -> dict:
"""Estima o custo de treino antes de lançar a tarefa."""
total_tokens = 0
with open(jsonl_file, "r") as f:
num_examples = 0
for line in f:
num_examples += 1
obj = json.loads(line)
for msg in obj["messages"]:
# Estimativa grosseira: 1 token ~ 4 caracteres em português
total_tokens += len(msg["content"]) // 4
training_tokens = total_tokens * n_epochs
cost = training_tokens * price_per_million_tokens / 1_000_000
return {
"examples": num_examples,
"tokens_per_pass": total_tokens,
"epochs": n_epochs,
"total_tokens": training_tokens,
"estimated_cost": f"${cost:.2f}"
}
result = estimate_training_cost(
"training_data.jsonl",
n_epochs=3,
price_per_million_tokens=8.0 # verifique os preços atuais
)
for k, v in result.items():
print(f"{k}: {v}")
O Custo de Inferência
A inferência é faturada por chamada, com base nos tokens de entrada e saída, e os modelos ajustados têm geralmente uma taxa ligeiramente superior à do modelo base. Este sobrecusto unitário causa frequentemente hesitação, erroneamente: aplica-se a muito menos tokens, uma vez que o comportamento anteriormente descrito num prompt de sistema longo está agora integrado no modelo. O cálculo abaixo coloca ambos os cenários lado a lado para um mês de tráfego idêntico, com um prompt a cair de 800 para 100 tokens contra taxas duplicadas. Ajuste os parâmetros com os seus próprios números antes de tirar conclusões: para utilizações onde o prompt já era curto, a compensação inverte-se.
def monthly_cost(
requests_per_day: int,
avg_input_tokens: int,
avg_output_tokens: int,
price_input_per_million: float,
price_output_per_million: float
) -> float:
"""Calcula o custo mensal de inferência."""
requests_month = requests_per_day * 30
input_cost = requests_month * avg_input_tokens * price_input_per_million / 1_000_000
output_cost = requests_month * avg_output_tokens * price_output_per_million / 1_000_000
return input_cost + output_cost
# Cenário: modelo base com prompt longo
base_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=800, # prompt de sistema longo + pergunta
avg_output_tokens=200,
price_input_per_million=0.15,
price_output_per_million=0.60
)
# Cenário: modelo ajustado com prompt mínimo
ft_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=100, # prompt curto, comportamento integrado
avg_output_tokens=200,
price_input_per_million=0.30, # taxa FT mais elevada
price_output_per_million=1.20
)
print(f"Custo mensal base: ${base_cost:.2f}")
print(f"Custo mensal ajustado: ${ft_cost:.2f}")
print(f"Diferença: ${ft_cost - base_cost:+.2f}")
Reduzir os Tokens de Entrada
A principal alavanca de poupança com um modelo ajustado é a redução do prompt. Cada instrução que consegue remover porque o modelo a internalizou é um ganho repetido em cada chamada, até o serviço chegar ao fim da sua vida útil. A tabela abaixo apresenta as ordens de grandeza observadas consoante o grau de integração alcançado.
| Abordagem | Tokens de entrada | Poupança |
|---|---|---|
| Modelo base + prompt detalhado | 500-1000 tokens | Referência |
| Ajustado + prompt mínimo | 50-100 tokens | 80-90% na entrada |
| Ajustado + sem prompt de sistema | 20-50 tokens | 95% na entrada |
Não remova estas instruções todas de uma vez na esperança de que tudo se mantenha. Remova-as em grupos, voltando a executar o seu conjunto de testes após cada remoção: descobrirá que algumas regras foram perfeitamente aprendidas, enquanto outras, menos representadas nos seus exemplos, devem permanecer no prompt.
Equilibrar o Tamanho do Conjunto de Dados e as Épocas
Mais dados dão um modelo melhor, mas também um custo de treino mais elevado, e os retornos diminuem. Passar de cem para trezentos exemplos muda geralmente muito; passar de mil para três mil muda pouco, por três vezes o preço. Treine vários tamanhos, meça a qualidade alcançada e relacione-a com o custo para encontrar o seu ponto de equilíbrio.
def find_optimal(results_by_size: dict):
"""Identifica o tamanho ótimo do conjunto de dados."""
print("Tamanho dados | Pontuação qualidade | Custo treino")
print("-" * 55)
best_ratio = 0
optimal_size = 0
for size, data in sorted(results_by_size.items()):
score = data["score"]
cost = data["cost"]
ratio = score / cost if cost > 0 else 0
print(f"{size:>14} | {score:>13.2f} | {cost:>17.2f} $")
if ratio > best_ratio:
best_ratio = ratio
optimal_size = size
print(f"\nTamanho ótimo: {optimal_size} exemplos")
A escolha do modelo base pesa na mesma balança. O Luna é mais barato que o Terra, tanto para treino como para inferência: comece sempre pelo modelo mais barato e suba apenas se a qualidade alcançada for insuficiente. Verifique quais os modelos elegíveis para fine-tuning na documentação da OpenAI — a lista muda com cada geração e nunca cobre todo o catálogo. Depois, há o número de épocas, uma vez que cada passagem adicional multiplica mecanicamente o custo de treino. Se 2 épocas derem 95% da qualidade de 4 épocas, a escolha é rápida.
Monitorizar Gastos em Produção
A estimativa feita antes do lançamento aplica-se apenas ao treino. Em produção, é o tráfego real que impulsiona os custos, e muitas vezes surpreende para cima. Um contador alimentado em cada chamada, ligado a um orçamento mensal, alerta-o antes da fatura. O limiar de 80% deixa tempo para reagir: reduzir um prompt, limitar os comprimentos de resposta ou desviar algum tráfego para um modelo mais barato.
class CostTracker:
"""Rastreio de custos em tempo real."""
def __init__(self, monthly_budget: float):
self.budget = monthly_budget
self.spending = 0.0
self.calls = 0
def record(self, input_tokens: int, output_tokens: int,
input_price: float, output_price: float):
"""Regista o custo de uma chamada."""
cost = (
input_tokens * input_price / 1_000_000 +
output_tokens * output_price / 1_000_000
)
self.spending += cost
self.calls += 1
# Alerta se se aproximar do orçamento
utilization = self.spending / self.budget * 100
if utilization > 80:
print(f"ALERTA: {utilization:.1f}% do orçamento mensal utilizado")
def report(self):
"""Relatório de consumo."""
print(f"Chamadas: {self.calls}")
print(f"Gastos: ${self.spending:.2f}")
print(f"Orçamento restante: ${self.budget - self.spending:.2f}")
if self.calls > 0:
print(f"Custo médio por chamada: ${self.spending / self.calls:.4f}")
Justificar o Investimento
Resta a questão que a sua liderança fará mais cedo ou mais tarde: quanto tempo até que o treino se pague a si mesmo? O cálculo relaciona um custo único com um benefício mensal, que soma as poupanças de tokens e o valor que atribui aos ganhos de qualidade. Este segundo termo é o mais complicado, e é melhor deixá-lo em zero do que inventá-lo: um retorno demonstrado apenas com poupanças mensuráveis tem mais poder de convicção do que uma projeção generosa.
def calculate_roi(
training_cost: float,
monthly_savings: float,
quality_gain_value: float = 0
) -> dict:
"""Calcula o retorno sobre o investimento do fine-tuning."""
monthly_benefit = monthly_savings + quality_gain_value
payback_months = training_cost / monthly_benefit if monthly_benefit > 0 else float("inf")
return {
"training_cost": f"${training_cost:.2f}",
"monthly_benefit": f"${monthly_benefit:.2f}",
"payback": f"{payback_months:.1f} meses",
"annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
}
Pontos-chave
- Estime o custo de treino antes de lançar a tarefa
- A principal alavanca de poupança é reduzir os tokens de entrada
- Comece com o modelo base mais barato (Luna) antes de subir para o Terra
- Monitore os custos em produção com alertas de orçamento
- Calcule o ROI incluindo ganhos de qualidade e poupança de tokens