Escolher um modelo de embeddings é rodar um experimento, não ler um ranking. O método que dá uma resposta defensável tem oito passos: escrever os requisitos, montar uma lista curta de candidatos, construir um conjunto de avaliação com consultas e documentos seus, rodar cada candidato do jeito que ele foi treinado, calcular recall@k, MRR e nDCG, comparar com intervalo de confiança, pesar dimensão, armazenamento e latência e, por fim, registrar a decisão com um plano de troca.
Pontos-chave
- Benchmark público serve para cortar a lista de candidatos. O veredito sai dos seus dados, porque domínio, idioma e tamanho de trecho mudam a ordem dos modelos.
- O conjunto de avaliação é o ativo que fica: consultas reais, documentos reais e julgamento de relevância feito por quem conhece o assunto.
- Recall@k responde “o trecho certo chegou ao modelo gerador?”. MRR e nDCG respondem “chegou em que posição?”. Você precisa das duas leituras.
- Diferença pequena entre dois modelos, sem intervalo de confiança, é ruído até prova em contrário.
- Dimensão do vetor é custo recorrente: N vetores vezes d dimensões vezes 4 bytes em float32, fora o índice.
- Trocar de modelo obriga a reindexar tudo. Vetores de modelos diferentes não se comparam.
Antes de começar: o que você precisa ter em mãos
Você precisa de três coisas. Um corpus representativo, já dividido em trechos com a mesma estratégia que vai para produção. Um log de consultas reais, ou, na falta dele, pessoas do negócio dispostas a escrever perguntas como os usuários escreveriam. E clareza sobre a tarefa: este guia trata de recuperação para RAG e busca semântica. Classificação, agrupamento e deduplicação usam os mesmos vetores, mas pedem outras métricas.
Se você ainda está decidindo se recuperação é mesmo o caminho, leia antes a comparação entre prompt, RAG e fine-tuning. Não adianta escolher o melhor modelo de embeddings para um problema que se resolve com um prompt maior.
Passo 1: Escreva os requisitos antes de abrir qualquer ranking
O erro que todo mundo comete é começar pelo topo de um leaderboard e descobrir tarde que o modelo não aceita o tamanho do seu trecho ou não pode sair do seu ambiente. Preencha esta tabela primeiro. Cada linha elimina candidatos sem gastar uma única chamada.
| Requisito | Pergunta a responder | O que elimina |
|---|---|---|
| Idioma | Consultas e documentos estão só em português? Há consulta em um idioma e documento em outro? | Modelos monolíngues em inglês; modelos sem alinhamento entre idiomas |
| Comprimento de entrada | Qual o tamanho, em tokens, do maior trecho? | Modelos cujo limite de sequência trunca o seu trecho em silêncio |
| Onde roda | O texto pode ir a uma API externa? Há exigência de ambiente próprio? | APIs hospedadas ou, no sentido inverso, modelos que você não tem hardware para servir |
| Licença | O uso comercial é permitido? Há restrição de redistribuição? | Pesos com licença só para pesquisa |
| Latência de consulta | Quanto do orçamento de tempo cabe à vetorização da pergunta? | Modelos grandes demais para o seu hardware de inferência |
| Dimensão e armazenamento | Quantos vetores hoje e em dois anos? Quanto de memória o índice pode usar? | Dimensões altas sem opção de truncamento ou quantização |
| Assimetria | Consulta curta contra documento longo, ou textos de mesmo tipo? | Modelos treinados só para similaridade simétrica de sentenças |
Sobre a linha “onde roda”: rodar por conta própria e usar API são decisões com custos de natureza diferente. O texto sobre como rodar modelos de IA localmente ajuda a dimensionar a primeira opção, e o artigo sobre o que significa um modelo ser aberto evita surpresas com licença.
Passo 2: Monte uma lista curta de candidatos
Três a cinco modelos, mais uma linha de base. Para chegar neles, use um benchmark aberto de embeddings de texto como filtro: olhe só as tarefas de recuperação, só os conjuntos no seu idioma, e descarte o que não passa na tabela do Passo 1. A posição geral no ranking mistura tarefas que não são a sua.
Duas ressalvas de quem já foi enganado por tabela pública. Primeira: modelos podem ter visto, no treino, dados dos próprios conjuntos de avaliação, o que infla a nota. Segunda: os conjuntos públicos de recuperação, como os reunidos em uma conhecida coleção heterogênea de tarefas de recuperação de informação, têm perguntas e documentos que não se parecem com o seu contrato, o seu manual ou o seu chamado de suporte.
A linha de base é busca léxica com BM25, disponível em qualquer biblioteca de busca textual de código aberto. Ela custa quase nada e, em corpus cheio de códigos, siglas e nomes próprios, é mais difícil de bater do que parece. Se nenhum candidato supera a linha de base com folga, a conversa passa a ser busca híbrida, não troca de modelo.
Passo 3: Construa o conjunto de avaliação com os seus dados
É aqui que o trabalho rende. Um conjunto de avaliação de recuperação tem três partes: consultas, corpus e julgamentos de relevância (quais trechos respondem cada consulta).
Consultas
Prefira consultas do log, amostradas por estrato: frequentes, raras, curtas, longas, com erro de digitação, com jargão interno. Se você precisar gerar consultas com um LLM a partir dos trechos, saiba o viés que isso cria: a pergunta sintética tende a repetir o vocabulário do trecho de origem, o que favorece qualquer modelo e esconde a diferença entre eles. Peça paráfrase, misture com consultas humanas e reporte os dois grupos separados.
Julgamentos de relevância
Para cada consulta, marque todos os trechos que a respondem, não só o primeiro que você encontrar. Julgamento incompleto pune o modelo que acha um trecho correto que ninguém rotulou. A técnica padrão é o pooling: junte os primeiros resultados de todos os candidatos e da linha de base, embaralhe, esconda a origem e peça o julgamento sobre essa união.
Tamanho e negativos difíceis
O corpus de avaliação precisa conter distratores de verdade: versões antigas do mesmo documento, produtos com nomes parecidos, cláusulas quase iguais. Com corpus pequeno e limpo, todo modelo chega perto do teto e você não distingue nada. Quanto às consultas, poucas dezenas servem para depurar o pipeline. Para comparar modelos, você vai querer algumas centenas, pelo motivo estatístico do Passo 6.
Guarde esse conjunto junto da sua suíte de evals, com versão. Ele vai ser reutilizado a cada modelo novo que aparecer.
Passo 4: Rode cada candidato do jeito que ele foi treinado
O defeito mais comum em comparação de modelos é este: o candidato perdeu porque foi usado errado. Antes de medir, confira na documentação de cada candidato os itens abaixo.
- Prefixos ou instruções. Vários modelos esperam um texto antes da consulta e outro antes do documento. Sem eles, a qualidade cai e nada avisa você.
- Função de similaridade. Cosseno, produto interno ou distância euclidiana. Com vetores normalizados, cosseno e produto interno ordenam igual. Sem normalização, não.
- Limite de sequência. Conte os tokens com o tokenizador do próprio modelo. O que passa do limite é descartado sem erro.
- Pooling. Média dos tokens, token inicial ou último token: use o que o modelo define, não o padrão da biblioteca.
Mantenha o resto idêntico entre os candidatos: mesma divisão em trechos, mesmo corpus, mesma busca exata (sem índice aproximado nesta fase, para não misturar erro do índice com erro do modelo). Uma biblioteca de embeddings de sentenças resolve o carregamento de modelos abertos, e um repositório público de modelos traz os cartões com prefixos, limites e licença.
Passo 5: Calcule recall@k, MRR e nDCG
Três métricas, três perguntas diferentes.
| Métrica | Fórmula por consulta | Quando pesa mais |
|---|---|---|
| Recall@k | relevantes entre os k primeiros / total de relevantes | RAG: o k é o número de trechos que você entrega ao gerador ou ao reranker |
| MRR | 1 / posição do primeiro relevante (0 se não aparecer) | Busca em que o usuário quer uma resposta e olha o topo |
| nDCG@k | DCG / DCG ideal, com DCG = soma de rel_i / log2(i + 1) | Vários relevantes por consulta e ordem importando |
O código abaixo calcula as três com busca exata. Ele assume relevância binária e devolve um valor por consulta, não a média, porque o Passo 6 precisa dos valores individuais.
import numpy as np
def normalizar(m):
m = np.asarray(m, dtype=np.float32)
return m / np.linalg.norm(m, axis=1, keepdims=True)
def avaliar(emb_consultas, emb_docs, relevantes, k=10):
"""relevantes[i] = conjunto de índices de documentos corretos da consulta i."""
sims = normalizar(emb_consultas) @ normalizar(emb_docs).T
topo = np.argsort(-sims, axis=1)[:, :k]
recall, rr, ndcg = [], [], []
for i, rel in enumerate(relevantes):
acertos = [1.0 if d in rel else 0.0 for d in topo[i]]
recall.append(sum(acertos) / len(rel))
rr.append(next((1 / (p + 1) for p, a in enumerate(acertos) if a), 0.0))
dcg = sum(a / np.log2(p + 2) for p, a in enumerate(acertos))
ideal = sum(1 / np.log2(p + 2) for p in range(min(len(rel), k)))
ndcg.append(dcg / ideal)
return np.array(recall), np.array(rr), np.array(ndcg)
def bootstrap_diferenca(a, b, n=10000, semente=0):
"""IC de 95% para a diferença média pareada entre dois modelos."""
rng = np.random.default_rng(semente)
d = np.asarray(a) - np.asarray(b)
idx = rng.integers(0, len(d), size=(n, len(d)))
medias = d[idx].mean(axis=1)
return d.mean(), np.percentile(medias, 2.5), np.percentile(medias, 97.5)
def truncar(m, dims):
"""Só faz sentido em modelos treinados para isso (Matryoshka)."""
return normalizar(np.asarray(m)[:, :dims])
Confira a implementação com um caso resolvido à mão. Uma consulta tem dois trechos relevantes, e o modelo os coloca nas posições 2 e 5, com k = 5:
Recall@5 = 2 / 2 = 1,0
RR = 1 / 2 = 0,5
DCG@5 = 1/log2(3) + 1/log2(6) = 0,6309 + 0,3869 = 1,0178
DCG ideal (relevantes nas posições 1 e 2) = 1/log2(2) + 1/log2(3) = 1 + 0,6309 = 1,6309
nDCG@5 = 1,0178 / 1,6309 = 0,6241
Com k = 3, só o primeiro relevante entra: Recall@3 = 0,5 e nDCG@3 = 0,6309 / 1,6309 = 0,3869. A função avaliar devolve exatamente esses valores para esse caso. Escolha o k pelo desenho do sistema: se você entrega cinco trechos ao gerador, recall@5 é o número que importa; se há um reranker depois, meça recall no k que alimenta o reranker.
Passo 6: Compare com intervalo de confiança
Recall@10 de 0,80 contra 0,78 em cem consultas não autoriza conclusão nenhuma. As duas médias vêm das mesmas consultas, então o teste certo é pareado: calcule a diferença consulta a consulta e estime o intervalo dessa diferença. A função bootstrap_diferenca do bloco anterior faz isso por reamostragem com reposição.
Para calibrar a intuição, veja a saída da função em uma simulação com 200 consultas e dois modelos de acerto parecido: diferença média de 0,010, com intervalo de 95% entre -0,070 e 0,095. O intervalo contém o zero com folga: com esse tamanho de amostra, os dois modelos são indistinguíveis. A leitura prática tem três saídas.
- Intervalo todo acima de zero: A é melhor nesse conjunto. Siga para o Passo 7.
- Intervalo contém zero: empate técnico. Decida por custo, latência e operação, ou rotule mais consultas.
- Intervalo todo abaixo de zero: B é melhor.
Depois da média, leia os erros. Separe as consultas em que cada modelo falha e procure padrão: siglas, números de peça, perguntas negativas, textos longos. Muitas vezes a decisão sai daí, porque um modelo erra justamente o tipo de consulta que o negócio mais valoriza. Reporte também as métricas por estrato definido no Passo 3.
Passo 7: Pese dimensão, armazenamento e latência
Qualidade empatada ou quase, o desempate é operacional. A conta de armazenamento bruto é direta:
bytes = N * d * 4 (float32)
Cenário hipotético, N = 1.000.000 de trechos:
d = 1024 -> 1.000.000 * 1024 * 4 = 4.096.000.000 bytes = 4,096 GB
d = 384 -> 1.000.000 * 384 * 4 = 1.536.000.000 bytes = 1,536 GB
d = 1024 em int8 (1 byte por dimensão) = 1,024 GB
Some a isso a estrutura do índice aproximado, que em grafos do tipo HNSW cresce com o número de vizinhos por nó, e lembre que busca rápida pede esse volume em memória. Duas técnicas reduzem a conta, e as duas precisam ser medidas no seu conjunto antes de adotadas.
A primeira é o truncamento de dimensões. Só funciona em modelos treinados com aprendizado de representação do tipo Matryoshka, em que as primeiras dimensões concentram a informação. A função truncar mostra o procedimento: cortar e renormalizar. Aplicar isso em um modelo que não foi treinado para tal destrói a qualidade. A segunda é a quantização, escalar (int8) ou binária, normalmente combinada com uma reordenação final usando os vetores completos. Uma biblioteca de busca vetorial com índices quantizados permite testar as variantes sem subir infraestrutura.
Em latência, meça dois tempos separados: vetorizar a consulta (uma por requisição, no caminho crítico) e vetorizar o corpus (em lote, fora dele). O primeiro entra no orçamento descrito no guia de latência de aplicações com LLM. O segundo define quanto tempo leva uma reindexação completa, número que você vai querer conhecer antes do Passo 8. Em API hospedada, o custo segue a contagem de tokens, e vale revisar como tokens viram custo para estimar a indexação inicial.
Passo 8: Decida, registre e planeje a troca
Escreva a decisão em uma página: candidatos, versão do conjunto de avaliação, métricas com intervalo, custo estimado e o motivo da escolha. Daqui a um ano alguém vai propor um modelo novo, e essa página transforma uma discussão de opinião em uma reexecução do experimento.
Registre também a identidade exata do modelo: nome, revisão dos pesos ou versão da API, prefixos usados, dimensão, normalização. Grave isso como metadado do índice. Se o fornecedor atualizar o modelo por trás do mesmo nome, consultas novas e documentos antigos passam a viver em espaços diferentes, e a qualidade cai sem erro nenhum no log.
Planeje a troca como migração: índice novo construído em paralelo, avaliação no índice novo, virada por alias e índice antigo mantido até a confirmação. Nunca misture vetores de dois modelos na mesma coleção.
Erros comuns ao escolher um modelo de embeddings
- Escolher pela posição geral em um ranking. A média mistura tarefas e idiomas que não são os seus.
- Avaliar com consultas geradas a partir dos próprios trechos. A sobreposição de vocabulário infla todos os modelos.
- Medir com índice aproximado mal ajustado. Você avalia o índice, não o modelo.
- Declarar vencedor por diferença dentro do ruído. Sem intervalo, não há vencedor.
- Dispensar a linha de base léxica. Sem ela você não sabe quanto o vetor está agregando.
Perguntas frequentes sobre a escolha de modelos de embeddings
Modelo com mais dimensões é sempre melhor?
Não. Dimensão é capacidade, não garantia. Um modelo menor e bem treinado para o seu idioma e tipo de texto pode superar um maior. Só a medição no seu conjunto responde.
Preciso fazer fine-tuning do modelo de embeddings?
Só depois de esgotar o resto. Se a análise de erros mostra falha sistemática em vocabulário do seu domínio e você tem pares de consulta e trecho relevante em quantidade, o ajuste fino costuma ajudar. Avalie com um conjunto separado do usado no treino.
Quantas consultas preciso rotular?
O suficiente para que o intervalo de confiança da diferença entre os candidatos seja mais estreito que a diferença que importa para você. Rode o bootstrap com o que tem e veja a largura do intervalo.
Um reranker dispensa a escolha cuidadosa do embedding?
Não. O reranker só reordena o que a primeira etapa trouxe. Se o trecho correto não está entre os candidatos, não há o que reordenar. Por isso o recall da primeira etapa é a métrica a proteger.
Conclusão: rotule primeiro, compare depois
Comece esta semana pelo que não depende de modelo nenhum: separe cem consultas reais, monte o corpus com os distratores e rotule os trechos relevantes por pooling. Com isso pronto, rodar três candidatos e a linha de base é trabalho de um dia com o código deste artigo e uma biblioteca de álgebra linear para Python. Leia as métricas com intervalo, abra os erros, faça a conta de armazenamento e registre a decisão. O modelo vai mudar de novo. O conjunto de avaliação é o que fica com você.