O fine-tuning costuma ser a primeira solução que as pessoas procuram quando um modelo erra algo, e muitas vezes é a errada. Ele custa coleta de dados, rotulagem, rodadas de treino e um modelo que agora você precisa manter. Muitas falhas desaparecem com um prompt mais claro, o retrieval do documento certo ou uma checagem no código sobre a saída. Este post ajuda a decidir em qual caso você está, e o que preparar se realmente precisar de um modelo personalizado.
Que problema você está tentando resolver?
Dê nome à falha antes de dar nome à solução. A maioria das falhas de LLM cai em alguns padrões, e cada um tem um primeiro passo mais barato:
| Sintoma | Tente primeiro | O fine-tuning ajuda quando |
|---|---|---|
| Fatos errados ou desatualizados | Retrieval (RAG) sobre os seus documentos | Raramente; fatos que mudam precisam de retrieval de qualquer jeito |
| Formato errado, JSON quebrado | Saída estruturada, checagens de esquema, uma retentativa | O formato é incomum e exemplos no prompt não bastam |
| Rótulos ou categorias inconsistentes | Definições claras e exemplos few-shot | O conjunto de rótulos é grande ou sutil e os exemplos não cabem no prompt |
| Tom ou estilo errado | Um guia de estilo no prompt de sistema, com exemplos | Um estilo da casa precisa se manter em milhares de saídas |
| Termos do domínio ouvidos ou escritos errado | Uma lista de vocabulário no prompt, pós-correção no código | Modelos de fala erram repetidamente os mesmos nomes, códigos ou números |
| Lento ou caro demais em escala | Um modelo menor, prompt caching, prompts mais curtos | Um modelo pequeno com fine-tuning pode igualar um grande em uma tarefa restrita |
| Idioma ou dialeto errado | Instruções no idioma certo; veja engenharia de prompt em árabe | O modelo entende, mas não escreve no dialeto de que você precisa |
O próprio guia da OpenAI descreve a mesma ordem: primeiro escreva avaliações, depois itere nos prompts, e use fine-tuning para alguns casos de uso. Ele diz que o processo de engenharia de prompt “may be all you need in order to get great results.” (tradução: “pode ser tudo de que você precisa para obter ótimos resultados”). E lista o que o fine-tuning acrescenta ao prompting: mais exemplos do que cabem em um prompt, prompts mais curtos que economizam tokens, treino com dados que você não quer enviar em toda requisição e deixar um modelo menor bom em uma tarefa.
Como provar que a falha é recorrente?
Com um conjunto de avaliação. Reúna de 100 a 200 entradas reais com saídas corretas conhecidas, como em avaliar um LLM antes de trocar. Pontue o seu prompt atual. Depois rotule cada falha com uma categoria curta: wrong_label, missing_field, dialect, hallucinated_fact e assim por diante.
Um padrão só é candidato a fine-tuning se as três condições forem verdadeiras:
- É frequente. Responde por uma parcela relevante das falhas, não por um ou dois casos esquisitos.
- Sobrevive às soluções baratas. Você tentou instruções mais claras, exemplos, retrieval e validação, e a categoria continua lá.
- É consistente. As pessoas concordam sobre a resposta certa. Se dois dos seus próprios revisores rotulam o mesmo caso de formas diferentes, um modelo treinado com esses rótulos vai aprender a discordância.
Registre o resultado em uma frase curta, como neste exemplo inventado: “No nosso conjunto de suporte em árabe com 200 casos, o melhor prompt rotula 18% dos tickets de cobrança como entrega; exemplos few-shot reduzem isso para 15%.” Essa frase é o briefing de um fine-tune, e o número a superar.
Quais mudanças mais simples você deve testar primeiro?
Rode-as em ordem de custo e pontue de novo depois de cada uma:
- Instruções. Defina cada rótulo ou campo. Diga o que fazer em caso de dúvida.
- Exemplos. Acrescente de três a dez exemplos reais, incluindo os casos difíceis.
- Retrieval. Se as respostas precisam de fatos, recupere o trecho relevante. Busca RAG em árabe e contexto longo vs RAG cobrem as escolhas.
- Restrições. Use saída estruturada quando o modelo suportar e confira a saída no código. Peça de novo uma vez, informando o erro.
- Outro modelo. Um modelo base diferente pode já fazer o que você precisa. O mesmo conjunto de avaliação mostra isso em uma hora.
Cada passo custa horas, não semanas, e cada um deixa uma referência melhor para um fine-tune superar, se você ainda precisar de um.
De quais dados você precisa, e você tem o direito de usá-los?
Antes da qualidade, verifique os direitos. Dados de treino muitas vezes vêm de conversas com clientes, documentos ou gravações de chamadas. Você precisa de uma base legal e, muitas vezes, de consentimento ou de uma cláusula contratual que cubra o treino. Confira o seu próprio aviso de privacidade e os contratos com clientes, e remova dados pessoais de que você não precisa. Não presuma que o seu provedor de API está coletando isso por você: a declaração de privacidade da BroadNet, por exemplo, diz que ela não retém o conteúdo da inferência e não usa dados de inferência para treinar, fazer fine-tuning ou avaliar modelos.
Depois verifique a qualidade. Este script lê um arquivo de treino e um arquivo de avaliação no formato JSONL de chat mais comum (um {"messages": [...]} por linha, terminando com a resposta do assistente) e aponta problemas que estragam fine-tunes em silêncio: linhas quebradas, duplicatas, a mesma entrada com respostas diferentes, itens de avaliação que vazaram para o treino, equilíbrio de rótulos e possíveis dados pessoais.
import json, re, sys
from collections import Counter
DIAC = re.compile(r"[ً-ٰٟـ]") # tashkeel, dagger alef, tatweel
PII = {"email": re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+"),
"phone": re.compile(r"(?:\+|00)\d[\d\s-]{7,}\d")}
def norm(s: str) -> str:
s = DIAC.sub("", s.lower())
s = re.sub("[إأآٱ]", "ا", s).replace("ى", "ي")
return " ".join(s.split())
def load(path):
rows, errors = [], []
for i, line in enumerate(open(path, encoding="utf-8"), 1):
try:
ex = json.loads(line)
roles = [m["role"] for m in ex["messages"]]
if roles[-1] != "assistant" or "user" not in roles:
raise ValueError(f"roles {roles}")
rows.append(ex)
except (ValueError, KeyError, IndexError, TypeError) as e:
errors.append(f"line {i}: {e}")
return rows, errors
def key(ex): # the input side, normalised: what the model sees
return norm(" ".join(m["content"] for m in ex["messages"] if m["role"] != "assistant"))
def check(train_path, eval_path):
train, errs = load(train_path)
evals, eval_errs = load(eval_path)
keys = Counter(key(e) for e in train)
labels = Counter(e["messages"][-1]["content"].strip() for e in train)
leaked = {key(e) for e in evals} & set(keys)
pii = Counter(k for e in train for m in e["messages"] for k, rx in PII.items() if rx.search(m["content"]))
conflicts = Counter()
seen = {}
for e in train:
k, a = key(e), e["messages"][-1]["content"].strip()
if k in seen and seen[k] != a:
conflicts[k] += 1
seen.setdefault(k, a)
return {"train_examples": len(train), "parse_errors": errs + eval_errs,
"duplicate_inputs": sum(n - 1 for n in keys.values() if n > 1),
"same_input_different_answer": len(conflicts),
"eval_items_also_in_train": len(leaked),
"answer_distribution": labels.most_common(5),
"examples_with_possible_pii": dict(pii)}
if __name__ == "__main__":
print(json.dumps(check(sys.argv[1], sys.argv[2]), ensure_ascii=False, indent=1))
Rodamos o script em um arquivo de brinquedo de sete linhas com tickets de suporte em árabe, inglês e espanhol. Ele encontrou uma linha sem resposta do assistente, duas entradas duplicadas (uma diferia só por um diacrítico, que o normalizador remove, como em normalização de texto em árabe), uma entrada rotulada como billing e também como other, um item de avaliação que também aparecia no treino e um número de telefone. Qualquer um deles faria o fine-tune parecer melhor ou pior do que é.
A normalização importa para o árabe. Sem ela, “متأخر” e “متأخِّر” contam como entradas diferentes, e uma quase cópia de um item de teste pode escapar para o treino.
Como avaliar um fine-tune de forma justa?
Use o mesmo conjunto de teste separado que você usou na referência, e mantenha-o fora do treino. Depois compare:
- Com o melhor prompt, não com o primeiro. Um fine-tune que vence um prompt fraco não prova nada.
- Por categoria e por idioma. Um ganho geral pode esconder uma queda no árabe enquanto o inglês melhora. Reporte cada um.
- No comportamento geral. Acrescente de 20 a 50 pedidos comuns que o modelo já resolvia bem. Um treino estreito pode piorar o comportamento fora da tarefa.
- Em custo e latência. Um fine-tune muitas vezes se justifica por um modelo menor fazer o trabalho. Meça também tokens e tempo por requisição.
Decida a regra de aprovação antes de ver os números, como no post sobre avaliação: por exemplo, “pelo menos 5 pontos melhor nos rótulos de cobrança, nenhuma categoria pior em mais de 2 pontos, árabe e inglês aprovados”.
O que muda quando você não pode fazer fine-tuning de modelos hospedados?
Menos APIs hospedadas oferecem fine-tuning self-service do que você imagina. A página de descontinuações da OpenAI registra uma atualização na sua plataforma de fine-tuning self-service: desde 7 de maio de 2026, organizações que nunca tinham rodado fine-tuning não podem mais criar jobs; desde 2 de julho de 2026, também não podem as organizações que não tinham rodado inferência num modelo ajustado nos últimos 60 dias; e a partir de 6 de janeiro de 2027 clientes ativos existentes não poderão mais criar novos jobs de fine-tuning. Modelos já ajustados continuam disponíveis para inferência até que seus modelos base sejam descontinuados.
A alternativa habitual é um modelo open-weight treinado com um método eficiente em parâmetros como o LoRA. O artigo do LoRA (Hu et al.) relata que, em comparação com o fine-tuning completo do GPT-3 175B com Adam, o LoRA pode reduzir o número de parâmetros treináveis em 10.000 vezes e a memória de GPU necessária em 3 vezes. Depois você precisa de um lugar para servir o resultado: o seu próprio hardware ou um provedor que hospede pesos personalizados. Modelos open-weight vs fechados trata desse trade-off.
Onde a BroadNet Inference entra
O BroadRouter é o site da própria BroadNet. A API self-service da BroadNet Inference não tem endpoint de fine-tuning: sua referência da API documenta apenas chat completions e transcrição de áudio. A mesma página diz “private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint.” (tradução: “endpoints privados, nossos fine-tunes em árabe e outros modelos sob demanda são acessados com um ID privado emitido junto com o endpoint”). As páginas de modelo da BroadNet listam um fine-tune da BroadNet do Cohere Transcribe Arabic para números, datas e nomes em áudio ruidoso como disponível sob demanda, com um ID de modelo privado por cliente, e dizem que o Gemma 4 VL 26B está disponível em um endpoint privado “including our Arabic fine-tunes” (tradução: “incluindo nossos fine-tunes em árabe”). São consultas feitas pela página de contato, não algo que você possa comprar ou treinar por conta própria; planejar um endpoint privado explica o que enviar.
Para tudo antes dessa etapa, os modelos públicos bastam para montar o seu conjunto de avaliação e a referência: Qwen3.8 27B e GLM 5.3 documentam saída estruturada, o Gemma 4 VL 26B roda com o crédito inicial de $5 e o BroadNet Transcribe Arabic cuida da fala a $0.0042 por minuto. O conteúdo da inferência não é retido; os metadados necessários de conta, cobrança e segurança são retidos conforme descrito na declaração de privacidade da BroadNet.
