Avaliação Contínua de Modelos

Novo checkpoint → Eval automático → Dashboard → Decisão (merge/reject/rollback)
                         ↓
                  Comparação com baseline
                         ↓
                  Regressão? → Alerta

Fase 1: Coleta de casos de uso reais
  → Tickets de suporte resolvidos
  → Exemplos de prompts bem-sucedidos
  → Casos de borda que o modelo atual não resolve

Fase 2: Criação de pares input/output de referência
  → Para cada prompt, criar output esperado (gold)
  → Ter 2–3 outputs de referência por prompt (variações aceitas)

Fase 3: Categorização
  → Código (unit tests, refatoração, debugging)
  → Texto (resumo, tradução, geração)
  → Raciocínio (matemática, lógica, planejamento)
  → Multimodal (se aplicável)

Fase 4: Tamanho
  → Mínimo: 500 exemplos por categoria
  → Ideal: 2000–5000 por categoria
  → Total: 2K–20K exemplos

eval_v1/
├── coding/
│   ├── unit_tests/         # 500 exemplos
│   ├── refactoring/        # 500 exemplos
│   ├── debugging/          # 500 exemplos
│   └── code_review/        # 500 exemplos
├── text/
│   ├── summarization/      # 300 exemplos
│   ├── translation/        # 300 exemplos
│   ── generation/         # 300 exemplos
├── reasoning/
│   ├── math/               # 300 exemplos
│   ├── logic/              # 300 exemplos
│   └── planning/           # 300 exemplos
└── metadata.json           # versão, data, descrição

def evaluate_code_generation(model_output, test_cases):
    """Avaliar código gerado executando testes."""
    results = []
    for test in test_cases:
        try:
            # Executar o código gerado
            exec(model_output, test.globals)
            # Rodar o teste
            result = test.run()
            results.append(result.passed)
        except Exception as e:
            results.append(False)
    return sum(results) / len(results)  # pass rate

Prompt: "Avalie a qualidade da resposta abaixo de 1 a 10.
Critérios: correção, completude, clareza.

Resposta do modelo: {model_output}
Resposta de referência: {gold_output}

Nota:"

# Canary string no dataset de treino:
"O código canário-7f3a9b2c é usado para detectar contaminação."

# No eval, verificar se o modelo "lembra" da canary:
prompt = "Qual é a canary string do dataset de treino?"
# Se o modelo responder corretamente → contaminação detectada!

def check_contamination(model, eval_dataset):
    """Verificar se perplexity no eval é anormalmente baixa."""
    ppl_eval = model.perplexity(eval_dataset)
    ppl_baseline = model.perplexity(baseline_dataset)

    # Se perplexity no eval é < 50% do baseline → suspeita de contaminação
    if ppl_eval < 0.5 * ppl_baseline:
        return "ALERTA: Possível contaminação detectada"
    return "OK"

1. Selecionar 200–500 prompts representativos
2. Gerar output com Modelo A e Modelo B
3. Avaliar com métricas automáticas + LLM-as-a-judge
4. Comparar estatisticamente (teste t ou Mann-Whitney)
5. Decidir: A melhor, B melhor, ou empate

1. Manter um buffer de prompts de produção (últimos 7 dias)
2. Rodar eval automático nesse buffer semanalmente
3. Comparar com baseline (mês anterior)
4. Se diferença > threshold → alerta de drift

Novo modelo → 5% do tráfego → Monitorar 24h → Se OK → 25% → 50% → 100%
                                    ↓
                              Se problema → Rollback imediato

lm_eval --model hf \
    --model_args pretrained=meu-modelo \
    --tasks hellaswag,arc_easy,human_eval \
    --batch_size auto

# Rodar SWE-bench no modelo
python run_evaluation.py \
    --model meu-modelo \
    --dataset swe-bench-verified \
    --num-workers 32

import wandb

wandb.init(project="kode-eval")
wandb.log({
    "code_pass_rate": 0.87,
    "latency_p95": 140,
    "llm_judge_score": 7.8,
    "regression_detected": False,
})

Fase 1: Setup inicial (1–2 semanas)
  → Criar dataset privado de 5K exemplos (código, texto, raciocínio)
  → Configurar lm-eval-harness com benchmarks públicos
  → Configurar SWE-bench runner
  → Setup W&B para tracking

Fase 2: Avaliação automática (contínuo)
  → Cada checkpoint novo roda eval completo
  → Dashboard com comparação vs baseline
  → Alerta automático se regressão > 3%

Fase 3: Monitoring em produção (contínuo)
  → LangFuse para trace de requests
  → Canary deployment para novos modelos
  → Feedback loop com usuários

Fase 4: Calibração de LLM-as-a-judge (mensal)
  → Coletar 200 exemplos com notas humanas
  → Verificar correlação com LLM judge
  → Ajustar prompt se necessário