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

Custos e Otimização

Aula 15 de 16 Atualizada a 2 de novembro de 2026 Avancado
Nesta página
  1. Compreender a Estrutura de Custos
  2. O Custo de Treino
  3. O Custo de Inferência
  4. Reduzir os Tokens de Entrada
  5. Equilibrar o Tamanho do Conjunto de Dados e as Épocas
  6. Monitorizar Gastos em Produção
  7. Justificar o Investimento
  8. Pontos-chave

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