Crie avaliações empíricas fortes

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ção

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

Exemplos de avaliações

O que mede: As 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 não ambígua, perfeita para tarefas com respostas categóricas claras, como análise de sentimento (positivo, negativo, neutro).

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

import anthropic

tweets = [
    {"text": "Este filme foi uma total perda de tempo. 👎", "sentiment": "negative"},
    {"text": "O novo álbum é 🔥! Tocando em repetição o dia todo.", "sentiment": "positive"},
    {"text": "Eu simplesmente adoro quando meu voo atrasa 5 horas. #melhordiadetodos", "sentiment": "negative"},  # Caso extremo: Sarcasmo
    {"text": "O enredo do filme foi terrível, mas a atuação foi fenomenal.", "sentiment": "mixed"},  # Caso extremo: Sentimento misto
    # ... mais 996 tweets
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        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"Classifique isso como 'positive', 'negative', 'neutral' ou '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"Precisão da Análise de Sentimento: {accuracy * 100}%")

O que mede: A similaridade de cosseno mede a similaridade entre dois vetores (neste caso, embeddings 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 produzir respostas semanticamente semelhantes, mesmo que a redação varie.

Exemplo 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": ["Qual é a sua política de devolução?", "Como posso devolver um item?", "Qual eh a sua politica d devolucao?"], "answer": "Nossa política de devolução permite..."},  # Caso extremo: Erros de digitação
    {"questions": ["Comprei algo na semana passada e não é bem o que eu esperava, então estava pensando se talvez eu pudesse devolver?", "Li online que sua política é de 30 dias, mas isso parece estar desatualizado porque o site foi atualizado há seis meses, então estou me perguntando qual é exatamente sua política atual?"], "answer": "Nossa política de devolução permite..."},  # Caso extremo: Pergunta longa e confusa
    {"questions": ["Sou prima da Jane e ela disse que vocês têm um ótimo atendimento ao cliente. Posso devolver isso?", "O Reddit me disse que entrar em contato com o atendimento ao cliente dessa forma era a maneira mais rápida de obter uma resposta. Espero que eles estejam certos! Qual é o prazo de devolução de uma jaqueta?"], "answer": "Nossa política de devolução permite..."},  # Caso extremo: Informações irrelevantes
    # ... mais 47 FAQs
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        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"Pontuação de Consistência da FAQ: {similarity_score * 100}%")

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. Altas pontuações ROUGE-L indicam que o resumo gerado captura informações-chave em uma ordem coerente.

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

from rouge import Rouge
import anthropic

articles = [
    {"text": "Em um estudo inovador, pesquisadores do MIT...", "summary": "Cientistas do MIT descobrem um novo antibiótico..."},
    {"text": "Jane Doe, uma heroína local, fez manchetes na semana passada por salvar... Em notícias da prefeitura, o orçamento... Meteorologistas preveem...", "summary": "Comunidade celebra heroína local Jane Doe enquanto cidade lida com questões orçamentárias."},  # Caso extremo: Múltiplos tópicos
    {"text": "Você não vai acreditar no que essa celebridade fez! ... extenso trabalho de caridade ...", "summary": "Extenso trabalho de caridade de celebridade surpreende fãs"},  # Caso extremo: Título enganoso
    # ... mais 197 artigos
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        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']  # Pontuação F1 ROUGE-L

outputs = [get_completion(f"Resuma este artigo em 1-2 frases:\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"Pontuação F1 ROUGE-L Média: {sum(relevance_scores) / len(relevance_scores)}")

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 avaliar 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.

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

import anthropic

inquiries = [
    {"text": "Esta é a terceira vez que vocês erram meu pedido. Quero um reembolso AGORA!", "tone": "empathetic"},  # Caso extremo: Cliente irritado
    {"text": "Tentei redefinir minha senha, mas minha conta foi bloqueada...", "tone": "patient"},  # Caso extremo: Problema complexo
    {"text": "Não acredito como seu produto é bom. Ele arruinou todos os outros para mim!", "tone": "professional"},  # Caso extremo: Elogio como reclamação
    # ... mais 97 consultas
]

client = anthropic.Anthropic()

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

def evaluate_likert(model_output, target_tone):
    tone_prompt = f"""Avalie esta resposta de atendimento ao cliente em uma escala de 1-5 por ser {target_tone}:
    <response>{model_output}</response>
    1: Nada {target_tone}
    5: Perfeitamente {target_tone}
    Responda apenas o número."""

    # Geralmente é uma boa prática usar um modelo diferente para avaliar do que o modelo usado para gerar a saída avaliada
    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"Responda a esta consulta do cliente: {inquiry['text']}") for inquiry in inquiries]
tone_scores = [evaluate_likert(output, inquiry['tone']) for output, inquiry in zip(outputs, inquiries)]
print(f"Pontuação Média de Tom: {sum(tone_scores) / len(tone_scores)}")

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 ou não. Este método pode entender o contexto e identificar formas sutis ou implícitas de PHI que os sistemas baseados em regras podem perder.

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

import anthropic

patient_queries = [
    {"query": "Quais são os efeitos colaterais do Lisinopril?", "contains_phi": False},
    {"query": "Você pode me dizer por que John Doe, nascido em 12/05/1980, recebeu prescrição de Metformina?", "contains_phi": True},  # Caso extremo: PHI explícito
    {"query": "Se minha amiga Alice, que nasceu em 4 de julho de 1985, tivesse diabetes, o que...", "contains_phi": True},  # Caso extremo: PHI hipotético
    {"query": "Estou preocupado com meu filho. Ele recebeu a mesma medicação que seu pai no ano passado.", "contains_phi": True},  # Caso extremo: PHI implícito
    # ... mais 496 consultas
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        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 = """Esta resposta contém ou faz referência a alguma Informação de Saúde Pessoal (PHI)?
    PHI se refere a quaisquer dados de saúde individualmente identificáveis que são criados, usados ou divulgados no curso da prestação de serviços de saúde. Isso inclui informações relacionadas à condição de saúde física ou mental de um indivíduo, à prestação de cuidados de saúde a esse indivíduo ou ao pagamento por tais cuidados.
    Aspectos-chave do PHI incluem:
    - Identificadores: Nomes, endereços, datas de nascimento, números de Seguro Social, números de prontuários médicos, etc.
    - Dados de saúde: Diagnósticos, planos de tratamento, resultados de exames, registros de medicamentos, etc.
    - Informações financeiras: Detalhes de seguro, registros de pagamento, etc.
    - Comunicação: Anotações de provedores de saúde, e-mails ou mensagens sobre saúde.

    <response>{model_output}</response>
    Responda apenas 'sim' ou 'não'."""

    # Geralmente é uma boa prática usar um modelo diferente para avaliar do que o modelo usado para gerar a saída avaliada
    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() == "não"

outputs = [get_completion(f"Você é um assistente médico. Nunca revele nenhum PHI em suas respostas. PHI se refere a quaisquer dados de saúde individualmente identificáveis que são criados, usados ou divulgados no curso da prestação de serviços de saúde. Isso inclui informações relacionadas à condição de saúde física ou mental de um indivíduo, à prestação de cuidados de saúde a esse indivíduo ou ao pagamento por tais cuidados. Aqui está a pergunta: {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"Pontuação de Preservação da Privacidade: {sum(privacy_scores) / len(privacy_scores) * 100}%")

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

Exemplo de casos de teste de avaliação: 100 conversas de várias etapas com perguntas dependentes do contexto.

import anthropic

conversations = [
    [
        {"role": "user", "content": "Acabei de ganhar um pomerânia novo!"},
        {"role": "assistant", "content": "Parabéns pelo seu novo amigo peludo! É seu primeiro cachorro?"},
        {"role": "user", "content": "Sim, é. Eu a chamei de Luna."},
        {"role": "assistant", "content": "Luna é um nome adorável! Como dono de cachorro de primeira viagem, você pode ter algumas dúvidas. O que você gostaria de saber sobre cuidar da Luna?"},
        ...
        {"role": "user", "content": "O que devo saber sobre cuidar de um cachorro dessa raça específica?"}  # Caso extremo: Depende do contexto de muito antes
    ],
    [
        {"role": "user", "content": "Estou lendo 'O Sol é Para Todos' para meu clube do livro."},
        {"role": "assistant", "content": "Ótima escolha! 'O Sol é Para Todos' de Harper Lee é um clássico que explora temas de injustiça racial e crescimento moral. Como você está achando até agora?"},
        {"role": "user", "content": "É poderoso. Ei, quando era o aniversário da Scout mesmo?"},  # Caso extremo: Mudança abrupta de tópico
        {"role": "assistant", "content": "Peço desculpas, mas não me lembro da data exata do aniversário da Scout sendo mencionada em 'O Sol é Para Todos'. O romance não se concentra em detalhes tão específicos. Em vez disso, ele se concentra no crescimento e nas experiências de Scout ao longo de vários anos. Há alguma parte específica do livro ou do desenvolvimento de Scout que você está interessado em discutir?"},
        {"role": "user", "content": "Ah, certo. Bem, você pode sugerir uma receita de um bolo clássico do sul?"}  # Caso extremo: Outra mudança de tópico
    ],
    # ... mais 98 conversas
]

client = anthropic.Anthropic()

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

def evaluate_ordinal(model_output, conversation):
    ordinal_prompt = f"""Avalie o quão bem esta resposta utiliza o contexto da conversa em uma escala de 1-5:
    <conversation>
    {"".join(f"{turn['role']}: {turn['content']}\\n" for turn in conversation[:-1])}
    </conversation>
    <response>{model_output}</response>
    1: Ignora completamente o contexto
    5: Utiliza perfeitamente o contexto
    Responda apenas o número e nada mais."""

    # Geralmente é uma boa prática usar um modelo diferente para avaliar do que o modelo usado para gerar a saída avaliada
    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"Pontuação Média de Utilização de Contexto: {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 exemplos de casos de teste.

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 brainstorm com o Claude!

Classificando avaliações

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

Classificação baseada em código: Mais rápida e confiável, extremamente escalável, mas também carece de nuances para julgamentos mais complexos que exigem 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 julgamentos complexos. 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 uma 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 exigem julgamento complexo.

import anthropic

def build_grader_prompt(answer, rubric):
    return f"""Classifique esta resposta com base na rubrica:
    <rubric>{rubric}</rubric>
    <answer>{answer}</answer>
    Pense no seu raciocínio em tags <thinking>, depois produza 'correto' ou 'incorreto' em tags <result>."""

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 "correto" if "correto" in grader_response.lower() else "incorreto"

# Exemplo de uso
eval_data = [
    {"question": "42 é a resposta para a vida, o universo e tudo?", "golden_answer": "Sim, de acordo com 'O Guia do Mochileiro das Galáxias'."},
    {"question": "Qual é a capital da França?", "golden_answer": "A capital da França é Paris."}
]

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        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"Pontuação: {grades.count('correto') / len(grades) * 100}%")

Próximos passos

Brainstorm de avaliações

Aprenda como criar prompts que maximizam 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.

Começar

Aprender sobre Claude

Construir com Claude

Testar e avaliar

Recursos

Crie avaliações empíricas fortes

Construindo avaliações e casos de teste

Princípios de design de avaliação

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

Começar

Aprender sobre Claude

Construir com Claude

Testar e avaliar

Recursos

​Construindo avaliações e casos de teste

​Princípios de design de avaliação

​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ção

Exemplos de avaliações

Classificando avaliações

Dicas para classificação baseada em LLM

Próximos passos