Como construir pipelines de avaliação de LLMs com dados sintéticos

1. Fundamentos da Avaliação de LLMs com Dados Sintéticos

A avaliação de Large Language Models (LLMs) enfrenta um desafio fundamental: a escassez e o custo de datasets humanos anotados. Dados sintéticos emergem como solução estratégica, permitindo criar conjuntos de teste sob medida, escaláveis e controlados.

Por que usar dados sintéticos? Diferente de datasets humanos tradicionais (como MMLU ou HellaSwag), os dados sintéticos oferecem:
- Escalabilidade: gere milhares de exemplos em minutos
- Cobertura de bordas: teste cenários raros ou específicos do seu domínio
- Redução de viés de anotação: evite inconsistências entre anotadores humanos

Desafios críticos: a qualidade do gerador de dados sintéticos impacta diretamente a validade da avaliação. Alucinações no gerador podem introduzir ground truth incorretas, comprometendo métricas. É essencial implementar camadas de validação.

2. Estratégias de Geração de Dados Sintéticos para Avaliação

Três abordagens principais dominam a geração de dados sintéticos para avaliação de LLMs:

Geração baseada em templates: crie perguntas parametrizadas com placeholders para entidades, números e contextos. Exemplo: "Qual a capital de {país}?" com resposta "A capital de {país} é {capital}."

Geração via LLM mestre: use um modelo como GPT-4 ou Claude para gerar pares pergunta-resposta. Prompt estruturado garante consistência:

Prompt: "Gere 5 perguntas de raciocínio lógico sobre relações familiares, cada uma com resposta correta. Formato: Pergunta: [texto] | Resposta: [texto]"

Saída esperada:
Pergunta: Se Ana é mãe de João e João é pai de Pedro, qual o parentesco entre Ana e Pedro? | Resposta: Ana é avó de Pedro.
...

Técnicas de diversificação: aplique variação semântica (sinônimos, reestruturação de frases), troca de entidades (personagens, locais) e inversão de contexto (pergunta → resposta reversa) para ampliar cobertura.

3. Estrutura de um Pipeline de Avaliação Modular

Um pipeline robusto possui três componentes essenciais:

  1. Gerador de dados: produz pares pergunta-resposta sintéticos
  2. Executor de inferência: submete perguntas ao LLM sob avaliação
  3. Coletor de métricas: compara respostas do LLM com ground truth

Arquitetura em etapas:

Geração → Filtragem → Amostragem → Inferência → Métricas → Relatório

Integre com ferramentas de rastreamento como Weights & Biases ou MLflow para versionar experimentos e comparar resultados entre rodadas de avaliação.

4. Métricas de Avaliação para Diferentes Capacidades do LLM

Métricas de factualidade: para respostas objetivas, use precisão, recall e F1. Exato match para perguntas fechadas, similaridade de substring para respostas abertas.

Métricas de consistência: avalie auto-consistência gerando múltiplas respostas para mesma pergunta (com temperatura > 0). Calcule similaridade semântica com BERTScore ou modelos NLI (Natural Language Inference).

Métricas de segurança: detecte toxicidade (perspectiva API, detoxify), viés (testes de associação implícita) e recusa apropriada (modelo deve recusar perguntas prejudiciais).

Exemplo de cálculo de F1 para respostas textuais:

def calculate_f1(prediction, ground_truth):
    pred_tokens = set(prediction.lower().split())
    truth_tokens = set(ground_truth.lower().split())

    if not pred_tokens or not truth_tokens:
        return 0.0

    intersection = pred_tokens & truth_tokens
    precision = len(intersection) / len(pred_tokens)
    recall = len(intersection) / len(truth_tokens)

    if precision + recall == 0:
        return 0.0

    return 2 * (precision * recall) / (precision + recall)

5. Controle de Qualidade e Validação dos Dados Sintéticos

Dados sintéticos de baixa qualidade contaminam a avaliação. Implemente filtros rigorosos:

Filtragem por heurísticas: remova exemplos com comprimento extremo (< 5 ou > 500 tokens), alta repetição de n-gramas (>70% bigramas repetidos) ou padrões suspeitos como "não sei" como resposta.

Amostragem e revisão humana: valide estatisticamente subconjuntos de 5-10% dos dados. Calcule concordância entre avaliador humano e gerador sintético (kappa de Cohen > 0.8 indica qualidade aceitável).

Detecção de alucinações: use um segundo LLM como verificador. Prompt:

Prompt: "A resposta '{resposta}' é factualmente correta para a pergunta '{pergunta}'? Responda apenas SIM ou NAO."

6. Implementação Prática do Pipeline

Exemplo 1: Geração de dados sintéticos com prompts estruturados

import json
from openai import OpenAI

client = OpenAI()

def generate_evaluation_data(num_samples=10, domain="biologia"):
    prompt = f"""Gere {num_samples} perguntas de múltipla escolha sobre {domain}.
    Cada pergunta deve ter 4 alternativas (A, B, C, D) e uma resposta correta.
    Formato JSON: {{"pergunta": "...", "alternativas": {{"A": "...", "B": "...", "C": "...", "D": "..."}}, "resposta": "A"}}"""

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7
    )

    return json.loads(response.choices[0].message.content)

# Gera 50 exemplos
dados_sinteticos = generate_evaluation_data(50, "história do brasil")

Exemplo 2: Execução paralela de avaliação em lote

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def evaluate_model(model, pergunta):
    # Simula chamada ao modelo
    time.sleep(0.1)
    return f"Resposta simulada para: {pergunta[:50]}..."

def batch_evaluation(model, perguntas, max_workers=8):
    resultados = {}
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {executor.submit(evaluate_model, model, p): i 
                   for i, p in enumerate(perguntas)}
        for future in as_completed(futures):
            idx = futures[future]
            resultados[idx] = future.result()
    return [resultados[i] for i in sorted(resultados.keys())]

# Uso
perguntas = [d["pergunta"] for d in dados_sinteticos]
respostas_modelo = batch_evaluation("meu-llm-testado", perguntas)

Exemplo 3: Cálculo de métricas e relatório final

def generate_report(perguntas, respostas_modelo, respostas_esperadas):
    acertos = 0
    total = len(perguntas)

    for pred, true in zip(respostas_modelo, respostas_esperadas):
        if pred.strip().lower() == true.strip().lower():
            acertos += 1

    acuracia = acertos / total

    relatorio = f"""
    RELATÓRIO DE AVALIAÇÃO
    =====================
    Total de perguntas: {total}
    Acertos: {acertos}
    Acurácia: {acuracia:.2%}

    Distribuição por categoria:
    """

    return relatorio

print(generate_report(perguntas, respostas_modelo, 
                      [d["resposta"] for d in dados_sinteticos]))

7. Casos de Uso e Boas Práticas

Avaliação comparativa entre modelos: gere um dataset sintético fixo e avalie baseline vs fine-tuned. Exemplo: comparar GPT-3.5 vs GPT-4 em raciocínio matemático com 200 perguntas geradas.

Testes de regressão após fine-tuning: após treinar com LoRA ou RLHF, execute o mesmo pipeline para detectar degradação em capacidades anteriores. Mantenha um dataset de regressão versionado.

Dicas para evitar overfitting no pipeline:
- Use seeds diferentes para geração de dados a cada rodada
- Amostre subconjuntos aleatórios do dataset sintético total
- Documente hiperparâmetros do gerador (modelo, temperatura, top-p)
- Versione tanto o dataset quanto o pipeline (DVC, Git LFS)

Reprodutibilidade: fixe versões de todas as dependências (transformers, datasets, torch) e registre o prompt exato usado na geração. Considere usar contêineres Docker para ambiente isolado.

Construir pipelines de avaliação com dados sintéticos não é apenas uma alternativa econômica — é uma prática que permite testar sistematicamente comportamentos específicos, detectar regressões e garantir qualidade contínua em LLMs em produção.

Referências

  • OpenAI Evals Framework — Framework oficial da OpenAI para avaliação de LLMs, inclui exemplos de geração de dados sintéticos e métricas padronizadas.
  • Hugging Face Datasets Library — Documentação oficial para criação, filtragem e validação de datasets sintéticos e reais para avaliação de modelos.
  • LangChain Evaluation Documentation — Guia prático para construir pipelines de avaliação com LangChain, incluindo geração de dados sintéticos por templates.
  • Weights & Biases LLM Evaluation — Tutorial sobre rastreamento de experimentos de avaliação de LLMs com métricas customizadas e visualização de resultados.
  • DeepLearning.AI: Evaluating and Debugging LLMs — Curso técnico com implementações práticas de pipelines de avaliação usando dados sintéticos e métricas de factualidade.