Avaliação de LLM

Domine estratégias abrangentes de avaliação para aplicações de LLM, desde métricas automatizadas até avaliação humana e testes A/B.

Quando Usar Esta Habilidade

• Medir o desempenho de aplicações de LLM de forma sistemática
• Comparar diferentes modelos ou prompts
• Detectar regressões de desempenho antes da implantação
• Validar melhorias de mudanças de prompt
• Construir confiança em sistemas de produção
• Estabelecer linhas de base e acompanhar o progresso ao longo do tempo
• Depurar comportamento inesperado do modelo

Tipos Principais de Avaliação

1. Métricas Automatizadas

Avaliação rápida, repetível e escalável usando pontuações computadas.

Geração de Texto:

• BLEU: Sobreposição de n-gramas (tradução)
• ROUGE: Orientado a recall (resumo)
• METEOR: Similaridade semântica
• BERTScore: Similaridade baseada em embeddings
• Perplexidade: Confiança do modelo de linguagem

Classificação:

• Acurácia: Porcentagem de acertos
• Precisão/Recall/F1: Desempenho específico da classe
• Matriz de Confusão: Padrões de erro
• AUC-ROC: Qualidade do ranking

Recuperação (RAG):

• MRR: Mean Reciprocal Rank (Rank Recíproco Médio)
• NDCG: Normalized Discounted Cumulative Gain (Ganho Cumulativo Descontado Normalizado)
• Precision@K: Relevante nos top K
• Recall@K: Cobertura nos top K

2. Avaliação Humana

Avaliação manual para aspectos de qualidade difíceis de automatizar.

Dimensões:

• Acurácia: Correção factual
• Coerência: Fluxo lógico
• Relevância: Responde à pergunta
• Fluidez: Qualidade da linguagem natural
• Segurança: Sem conteúdo prejudicial
• Utilidade: Útil para o usuário

3. LLM como Juiz

Use LLMs mais fortes para avaliar saídas de modelos mais fracos.

Abordagens:

• Ponto a Ponto: Pontuar respostas individuais
• Par a Par: Comparar duas respostas
• Baseado em Referência: Comparar com o padrão ouro
• Livre de Referência: Julgar sem verdade fundamental

Início Rápido

from dataclasses import dataclass
from typing import Callable
import numpy as np

@dataclass
class Metric:
    name: str
    fn: Callable

    @staticmethod
    def accuracy():
        return Metric("accuracy", calculate_accuracy)

    @staticmethod
    def bleu():
        return Metric("bleu", calculate_bleu)

    @staticmethod
    def bertscore():
        return Metric("bertscore", calculate_bertscore)

    @staticmethod
    def custom(name: str, fn: Callable):
        return Metric(name, fn)

class EvaluationSuite:
    def __init__(self, metrics: list[Metric]):
        self.metrics = metrics

    async def evaluate(self, model, test_cases: list[dict]) -> dict:
        results = {m.name: [] for m in self.metrics}

        for test in test_cases:
            prediction = await model.predict(test["input"])

            for metric in self.metrics:
                score = metric.fn(
                    prediction=prediction,
                    reference=test.get("expected"),
                    context=test.get("context")
                )
                results[metric.name].append(score)

        return {
            "metrics": {k: np.mean(v) for k, v in results.items()},
            "raw_scores": results
        }

# Usage
suite = EvaluationSuite([
    Metric.accuracy(),
    Metric.bleu(),
    Metric.bertscore(),
    Metric.custom("groundedness", check_groundedness)
])

test_cases = [
    {
        "input": "What is the capital of France?",
        "expected": "Paris",
        "context": "France is a country in Europe. Paris is its capital."
    },
]

results = await suite.evaluate(model=your_model, test_cases=test_cases)

Padrões detalhados e exemplos práticos

A documentação detalhada dos padrões está em references/details.md. Leia este arquivo quando o nível de navegação acima for insuficiente.