Avaliação de LLMs

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

Não use esta habilidade quando

• A tarefa não estiver relacionada à avaliação de LLM
• Você precisar de um domínio ou ferramenta diferente fora deste escopo

Instruções

• Clarifique objetivos, restrições e entradas necessárias.
• Aplique as melhores práticas relevantes e valide os resultados.
• Forneça etapas acionáveis e verificação.
• Use os exemplos abaixo; nenhum manual de implementação separado está incluído.

Use esta habilidade quando

• Medir o desempenho de aplicações de LLM sistematicamente
• Comparar diferentes modelos ou prompts
• Detectar regressões de desempenho antes da implantação
• Validar melhorias de alterações de prompt
• Construir confiança em sistemas de produção
• Estabelecer linhas de base e rastrear 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 Médio Recíproco)
• 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
• Fluência: 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:

• Pontual: Pontua respostas individuais
• Pareado: Compara duas respostas
• Baseado em Referência: Compara com o padrão ouro
• Livre de Referência: Julga sem verdade fundamental

Início Rápido

from llm_eval import EvaluationSuite, Metric

# Define evaluation suite
suite = EvaluationSuite([
    Metric.accuracy(),
    Metric.bleu(),
    Metric.bertscore(),
    Metric.custom(name="groundedness", fn=check_groundedness)
])

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

# Run evaluation
results = suite.evaluate(
    model=your_model,
    test_cases=test_cases
)

print(f"Overall Accuracy: {results.metrics['accuracy']}")
print(f"BLEU Score: {results.metrics['bleu']}")

Implementação de Métricas Automatizadas

Pontuação BLEU

from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction

def calculate_bleu(reference, hypothesis):
    """Calculate BLEU score between reference and hypothesis."""
    smoothie = SmoothingFunction().method4

    return sentence_bleu(
        [reference.split()],
        hypothesis.split(),
        smoothing_function=smoothie
    )

# Usage
bleu = calculate_bleu(
    reference="The cat sat on the mat",
    hypothesis="A cat is sitting on the mat"
)

Pontuação ROUGE

from rouge_score import rouge_scorer

def calculate_rouge(reference, hypothesis):
    """Calculate ROUGE scores."""
    scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
    scores = scorer.score(reference, hypothesis)

    return {
        'rouge1': scores['rouge1'].fmeasure,
        'rouge2': scores['rouge2'].fmeasure,
        'rougeL': scores['rougeL'].fmeasure
    }

BERTScore

from bert_score import score

def calculate_bertscore(references, hypotheses):
    """Calculate BERTScore using pre-trained BERT."""
    P, R, F1 = score(
        hypotheses,
        references,
        lang='en',
        model_type='microsoft/deberta-xlarge-mnli'
    )

    return {
        'precision': P.mean().item(),
        'recall': R.mean().item(),
        'f1': F1.mean().item()
    }

Métricas Personalizadas

def calculate_groundedness(response, context):
    """Verifica se a resposta está fundamentada no contexto fornecido."""
    # Usa modelo NLI para verificar a implicação
    from transformers import pipeline


…