Criar avaliações empíricas robustas

Após definir seus critérios de sucesso, o próximo passo é projetar avaliações para medir o desempenho do LLM em relação a esses critérios. Esta é uma parte vital do ciclo de engenharia de prompts.

Este guia se concentra em como desenvolver seus casos de teste.

Construindo avaliações e casos de teste

Princípios de design de avaliações

Seja específico para a tarefa: Projete avaliações que espelhem a distribuição de tarefas do mundo real. Não se esqueça de considerar casos extremos!
- Dados de entrada irrelevantes ou inexistentes
- Dados de entrada ou entrada do usuário excessivamente longos
- [Casos de uso de chat] Entrada do usuário inadequada, prejudicial ou irrelevante
- Casos de teste ambíguos onde até mesmo humanos achariam difícil chegar a um consenso de avaliação
Automatize quando possível: Estruture as perguntas para permitir classificação automatizada (por exemplo, múltipla escolha, correspondência de strings, classificação por código, classificação por LLM).
Priorize volume sobre qualidade: Mais perguntas com classificação automatizada de sinal ligeiramente menor é melhor do que menos perguntas com avaliações manuais de alta qualidade feitas por humanos.

Exemplos de avaliações

Fidelidade da tarefa (análise de sentimento) - avaliação de correspondência exata

O que mede: Avaliações de correspondência exata medem se a saída do modelo corresponde exatamente a uma resposta correta predefinida. É uma métrica simples e inequívoca, perfeita para tarefas com respostas categóricas claras, como análise de sentimento (positivo, negativo, neutro).

Exemplos de casos de teste de avaliação: 1000 tweets com sentimentos rotulados por humanos.

import anthropic

tweets = [
    {"text": "This movie was a total waste of time. 👎", "sentiment": "negative"},
    {"text": "The new album is 🔥! Been on repeat all day.", "sentiment": "positive"},
    {"text": "I just love it when my flight gets delayed for 5 hours. #bestdayever", "sentiment": "negative"},  # Edge case: Sarcasm
    {"text": "The movie's plot was terrible, but the acting was phenomenal.", "sentiment": "mixed"},  # Edge case: Mixed sentiment
    # ... 996 more tweets
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-opus-4-20250514",
        max_tokens=50,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_exact_match(model_output, correct_answer):
    return model_output.strip().lower() == correct_answer.lower()

outputs = [get_completion(f"Classify this as 'positive', 'negative', 'neutral', or 'mixed': {tweet['text']}") for tweet in tweets]
accuracy = sum(evaluate_exact_match(output, tweet['sentiment']) for output, tweet in zip(outputs, tweets)) / len(tweets)
print(f"Sentiment Analysis Accuracy: {accuracy * 100}%")

Consistência (bot de FAQ) - avaliação de similaridade de cosseno

O que mede: A similaridade de cosseno mede a semelhança entre dois vetores (neste caso, incorporações de frases da saída do modelo usando SBERT) calculando o cosseno do ângulo entre eles. Valores mais próximos de 1 indicam maior similaridade. É ideal para avaliar a consistência porque perguntas semelhantes devem gerar respostas semanticamente semelhantes, mesmo que a redação varie.

Exemplos de casos de teste de avaliação: 50 grupos com algumas versões parafraseadas cada.

from sentence_transformers import SentenceTransformer
import numpy as np
import anthropic

faq_variations = [
    {"questions": ["What's your return policy?", "How can I return an item?", "Wut's yur retrn polcy?"], "answer": "Our return policy allows..."},  # Edge case: Typos
    {"questions": ["I bought something last week, and it's not really what I expected, so I was wondering if maybe I could possibly return it?", "I read online that your policy is 30 days but that seems like it might be out of date because the website was updated six months ago, so I'm wondering what exactly is your current policy?"], "answer": "Our return policy allows..."},  # Edge case: Long, rambling question
    {"questions": ["I'm Jane's cousin, and she said you guys have great customer service. Can I return this?", "Reddit told me that contacting customer service this way was the fastest way to get an answer. I hope they're right! What is the return window for a jacket?"], "answer": "Our return policy allows..."},  # Edge case: Irrelevant info
    # ... 47 more FAQs
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-opus-4-20250514",
        max_tokens=2048,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_cosine_similarity(outputs):
    model = SentenceTransformer('all-MiniLM-L6-v2')
    embeddings = [model.encode(output) for output in outputs]

    cosine_similarities = np.dot(embeddings, embeddings.T) / (np.linalg.norm(embeddings, axis=1) * np.linalg.norm(embeddings, axis=1).T)
    return np.mean(cosine_similarities)

for faq in faq_variations:
    outputs = [get_completion(question) for question in faq["questions"]]
    similarity_score = evaluate_cosine_similarity(outputs)
    print(f"FAQ Consistency Score: {similarity_score * 100}%")

Relevância e coerência (resumo) - avaliação ROUGE-L

O que mede: ROUGE-L (Recall-Oriented Understudy for Gisting Evaluation - Longest Common Subsequence) avalia a qualidade dos resumos gerados. Ele mede o comprimento da subsequência comum mais longa entre os resumos candidato e de referência. Pontuações ROUGE-L altas indicam que o resumo gerado captura informações-chave em uma ordem coerente.

Exemplos de casos de teste de avaliação: 200 artigos com resumos de referência.

from rouge import Rouge
import anthropic

articles = [
    {"text": "In a groundbreaking study, researchers at MIT...", "summary": "MIT scientists discover a new antibiotic..."},
    {"text": "Jane Doe, a local hero, made headlines last week for saving... In city hall news, the budget... Meteorologists predict...", "summary": "Community celebrates local hero Jane Doe while city grapples with budget issues."},  # Edge case: Multi-topic
    {"text": "You won't believe what this celebrity did! ... extensive charity work ...", "summary": "Celebrity's extensive charity work surprises fans"},  # Edge case: Misleading title
    # ... 197 more articles
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-opus-4-20250514",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_rouge_l(model_output, true_summary):
    rouge = Rouge()
    scores = rouge.get_scores(model_output, true_summary)
    return scores[0]['rouge-l']['f']  # ROUGE-L F1 score

outputs = [get_completion(f"Summarize this article in 1-2 sentences:\n\n{article['text']}") for article in articles]
relevance_scores = [evaluate_rouge_l(output, article['summary']) for output, article in zip(outputs, articles)]
print(f"Average ROUGE-L F1 Score: {sum(relevance_scores) / len(relevance_scores)}")

Tom e estilo (atendimento ao cliente) - escala Likert baseada em LLM

O que mede: A escala Likert baseada em LLM é uma escala psicométrica que usa um LLM para julgar atitudes ou percepções subjetivas. Aqui, é usada para classificar o tom das respostas em uma escala de 1 a 5. É ideal para avaliar aspectos nuançados como empatia, profissionalismo ou paciência que são difíceis de quantificar com métricas tradicionais.

Exemplos de casos de teste de avaliação: 100 consultas de clientes com tom alvo (empático, profissional, conciso).

import anthropic

inquiries = [
    {"text": "This is the third time you've messed up my order. I want a refund NOW!", "tone": "empathetic"},  # Edge case: Angry customer
    {"text": "I tried resetting my password but then my account got locked...", "tone": "patient"},  # Edge case: Complex issue
    {"text": "I can't believe how good your product is. It's ruined all others for me!", "tone": "professional"},  # Edge case: Compliment as complaint
    # ... 97 more inquiries
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-opus-4-20250514",
        max_tokens=2048,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_likert(model_output, target_tone):
    tone_prompt = f"""Rate this customer service response on a scale of 1-5 for being {target_tone}:
    <response>{model_output}</response>
    1: Not at all {target_tone}
    5: Perfectly {target_tone}
    Output only the number."""

    # Generally best practice to use a different model to evaluate than the model used to generate the evaluated output 
    response = client.messages.create(model="claude-3-opus-20240229", max_tokens=50, messages=[{"role": "user", "content": tone_prompt}])
    return int(response.content[0].text.strip())

outputs = [get_completion(f"Respond to this customer inquiry: {inquiry['text']}") for inquiry in inquiries]
tone_scores = [evaluate_likert(output, inquiry['tone']) for output, inquiry in zip(outputs, inquiries)]
print(f"Average Tone Score: {sum(tone_scores) / len(tone_scores)}")

Preservação de privacidade (chatbot médico) - classificação binária baseada em LLM

O que mede: A classificação binária determina se uma entrada pertence a uma de duas classes. Aqui, é usada para classificar se uma resposta contém PHI (Informações de Saúde Protegidas) ou não. Este método pode entender o contexto e identificar formas sutis ou implícitas de PHI que sistemas baseados em regras podem perder.

Exemplos de casos de teste de avaliação: 500 consultas simuladas de pacientes, algumas com PHI.

import anthropic

patient_queries = [
    {"query": "What are the side effects of Lisinopril?", "contains_phi": False},
    {"query": "Can you tell me why John Doe, DOB 5/12/1980, was prescribed Metformin?", "contains_phi": True},  # Edge case: Explicit PHI
    {"query": "If my friend Alice, who was born on July 4, 1985, had diabetes, what...", "contains_phi": True},  # Edge case: Hypothetical PHI
    {"query": "I'm worried about my son. He's been prescribed the same medication as his father last year.", "contains_phi": True},  # Edge case: Implicit PHI
    # ... 496 more queries
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-opus-4-20250514",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_binary(model_output, query_contains_phi):
    if not query_contains_phi:
        return True

    binary_prompt = """Does this response contain or reference any Personal Health Information (PHI)?
    PHI refers to any individually identifiable health data that is created, used, or disclosed in the course of providing healthcare services. This includes information related to an individual's physical or mental health condition, the provision of healthcare to that individual, or payment for such care.
    Key aspects of PHI include:
    - Identifiers: Names, addresses, birthdates, Social Security numbers, medical record numbers, etc.
    - Health data: Diagnoses, treatment plans, test results, medication records, etc.
    - Financial information: Insurance details, payment records, etc.
    - Communication: Notes from healthcare providers, emails or messages about health.

    <response>{model_output}</response>
    Output only 'yes' or 'no'."""

    # Generally best practice to use a different model to evaluate than the model used to generate the evaluated output
    response = client.messages.create(model="claude-3-opus-20240229", max_tokens=50, messages=[{"role": "user", "content": binary_prompt}])
    return response.content[0].text.strip().lower() == "no"

outputs = [get_completion(f"You are a medical assistant. Never reveal any PHI in your responses. PHI refers to any individually identifiable health data that is created, used, or disclosed in the course of providing healthcare services. This includes information related to an individual's physical or mental health condition, the provision of healthcare to that individual, or payment for such care. Here is the question: {query['query']}") for query in patient_queries]
privacy_scores = [evaluate_binary(output, query['contains_phi']) for output, query in zip(outputs, patient_queries)]
print(f"Privacy Preservation Score: {sum(privacy_scores) / len(privacy_scores) * 100}%")

Utilização de contexto (assistente de conversação) - escala ordinal baseada em LLM

O que mede: Semelhante à escala Likert, a escala ordinal mede em uma escala fixa e ordenada (1-5). É perfeita para avaliar a utilização de contexto porque pode capturar o grau em que o modelo referencia e se baseia no histórico da conversa, o que é fundamental para interações coerentes e personalizadas.

Exemplos de casos de teste de avaliação: 100 conversas de múltiplos turnos com perguntas dependentes de contexto.

import anthropic

conversations = [
    [
        {"role": "user", "content": "I just got a new pomeranian!"},
        {"role": "assistant", "content": "Congratulations on your new furry friend! Is this your first dog?"},
        {"role": "user", "content": "Yes, it is. I named her Luna."},
        {"role": "assistant", "content": "Luna is a lovely name! As a first-time dog owner, you might have some questions. What would you like to know about caring for Luna?"},
        ...
        {"role": "user", "content": "What should I know about caring for a dog of this specific breed?"}  # Edge case: Relies on context from much earlier
    ],
    [
        {"role": "user", "content": "I'm reading 'To Kill a Mockingbird' for my book club."},
        {"role": "assistant", "content": "Great choice! 'To Kill a Mockingbird' by Harper Lee is a classic that explores themes of racial injustice and moral growth. How are you finding it so far?"},
        {"role": "user", "content": "It's powerful. Hey, when was Scout's birthday again?"},  # Edge case: Abrupt topic shift
        {"role": "assistant", "content": "I apologize, but I don't recall the exact date of Scout's birthday being mentioned in 'To Kill a Mockingbird'. The novel doesn't focus on such specific details. Instead, it centers on Scout's growth and experiences over several years. Is there a particular part of the book or Scout's development that you're interested in discussing?"},
        {"role": "user", "content": "Oh, right. Well, can you suggest a recipe for a classic Southern cake?"}  # Edge case: Another topic shift
    ],
    # ... 98 more conversations
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-opus-4-20250514",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_ordinal(model_output, conversation):
    ordinal_prompt = f"""Rate how well this response utilizes the conversation context on a scale of 1-5:
    <conversation>
    {"".join(f"{turn['role']}: {turn['content']}\\n" for turn in conversation[:-1])}
    </conversation>
    <response>{model_output}</response>
    1: Completely ignores context
    5: Perfectly utilizes context
    Output only the number and nothing else."""

    # Generally best practice to use a different model to evaluate than the model used to generate the evaluated output
    response = client.messages.create(model="claude-3-opus-20240229", max_tokens=50, messages=[{"role": "user", "content": ordinal_prompt}])
    return int(response.content[0].text.strip())

outputs = [get_completion(conversation) for conversation in conversations]
context_scores = [evaluate_ordinal(output, conversation) for output, conversation in zip(outputs, conversations)]
print(f"Average Context Utilization Score: {sum(context_scores) / len(context_scores)}")

Escrever centenas de casos de teste pode ser difícil de fazer manualmente! Peça ajuda ao Claude para gerar mais a partir de um conjunto básico de casos de teste de exemplo.

Se você não sabe quais métodos de avaliação podem ser úteis para avaliar seus critérios de sucesso, você também pode fazer um brainstorming com o Claude!

Classificando avaliações

Ao decidir qual método usar para classificar avaliações, escolha o método mais rápido, mais confiável e mais escalável:

Classificação baseada em código: Mais rápida e mais confiável, extremamente escalável, mas também carece de nuances para julgamentos mais complexos que requerem menos rigidez baseada em regras.
- Correspondência exata: output == golden_answer
- Correspondência de string: key_phrase in output
Classificação humana: Mais flexível e de alta qualidade, mas lenta e cara. Evite se possível.
Classificação baseada em LLM: Rápida e flexível, escalável e adequada para julgamento complexo. Teste para garantir a confiabilidade primeiro e depois escale.

Dicas para classificação baseada em LLM

Tenha rubricas detalhadas e claras: “A resposta deve sempre mencionar ‘Acme Inc.’ na primeira frase. Se não o fizer, a resposta é automaticamente classificada como ‘incorreta’.”
Um determinado caso de uso, ou mesmo um critério de sucesso específico para esse caso de uso, pode exigir várias rubricas para avaliação holística.
Empírico ou específico: Por exemplo, instrua o LLM a produzir apenas ‘correto’ ou ‘incorreto’, ou a julgar em uma escala de 1 a 5. Avaliações puramente qualitativas são difíceis de avaliar rapidamente e em escala.
Incentive o raciocínio: Peça ao LLM para pensar primeiro antes de decidir uma pontuação de avaliação e, em seguida, descarte o raciocínio. Isso aumenta o desempenho da avaliação, particularmente para tarefas que requerem julgamento complexo.

Exemplo: Classificação baseada em LLM

import anthropic

def build_grader_prompt(answer, rubric):
    return f"""Grade this answer based on the rubric:
    <rubric>{rubric}</rubric>
    <answer>{answer}</answer>
    Think through your reasoning in <thinking> tags, then output 'correct' or 'incorrect' in <result> tags.""

def grade_completion(output, golden_answer):
    grader_response = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=2048,
        messages=[{"role": "user", "content": build_grader_prompt(output, golden_answer)}]
    ).content[0].text

    return "correct" if "correct" in grader_response.lower() else "incorrect"

# Example usage
eval_data = [
    {"question": "Is 42 the answer to life, the universe, and everything?", "golden_answer": "Yes, according to 'The Hitchhiker's Guide to the Galaxy'."},
    {"question": "What is the capital of France?", "golden_answer": "The capital of France is Paris."}
]

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-opus-4-20250514",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

outputs = [get_completion(q["question"]) for q in eval_data]
grades = [grade_completion(output, a["golden_answer"]) for output, a in zip(outputs, eval_data)]
print(f"Score: {grades.count('correct') / len(grades) * 100}%")

Próximos passos

Brainstorm de avaliações

Aprenda como criar prompts que maximizem suas pontuações de avaliação.

Livro de receitas de avaliações

Mais exemplos de código de avaliações classificadas por humanos, código e LLM.

Primeiros passos

Explorar recursos

Modelos e preços

Saiba mais sobre Claude

Testar e avaliar

Centro Jurídico

Componentes do agente

Criar avaliações empíricas robustas

Construindo avaliações e casos de teste

Princípios de design de avaliações

Exemplos de avaliações

Classificando avaliações

Dicas para classificação baseada em LLM

Próximos passos

Brainstorm de avaliações

Livro de receitas de avaliações

Primeiros passos

Explorar recursos

Modelos e preços

Saiba mais sobre Claude

Testar e avaliar

Centro Jurídico

Componentes do agente

​Construindo avaliações e casos de teste

​Princípios de design de avaliações

​Exemplos de avaliações

​Classificando avaliações

​Dicas para classificação baseada em LLM

​Próximos passos

Brainstorm de avaliações

Livro de receitas de avaliações

Construindo avaliações e casos de teste

Princípios de design de avaliações

Exemplos de avaliações

Classificando avaliações

Dicas para classificação baseada em LLM

Próximos passos