Criar 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 prompt.

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 sua distribuição de tarefas do mundo real. Não se esqueça de considerar os 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 ruim, 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 perguntas para permitir classificação automatizada (por exemplo, múltipla escolha, correspondência de strings, avaliação por código, avaliação por LLM).
Priorize volume sobre qualidade: Mais perguntas com avaliaçã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

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: 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 é 🔥! Está em repetição o dia todo.", "sentiment": "positive"},
    {"text": "Adoro quando meu voo atrasa 5 horas. #melhordiademinhavida", "sentiment": "negative"},  # Caso extremo: Sarcasmo
    {"text": "O enredo do filme era 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-20241022",
        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 isto 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 por cosseno mede a similaridade entre dois vetores (neste caso, embeddings de sentenças 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 consistência porque perguntas similares devem gerar respostas semanticamente similares, mesmo que a redação varie.

Exemplos de casos de teste: 50 grupos com algumas versões parafraseadas cada.

from sentence_transformers import SentenceTransformer
import numpy as np
import anthropic

faq_variations = [
    {"questions": ["Qual é sua política de devolução?", "Como posso devolver um item?", "Ql é sua pltca 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 é realmente o que eu esperava, então estava me perguntando se talvez eu poderia possivelmente devolver?", "Li online que sua política é de 30 dias mas parece que pode 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 divagante
    {"questions": ["Sou primo da Jane, e ela disse que vocês têm um ótimo atendimento ao cliente. Posso devolver isto?", "O Reddit me disse que contatar o atendimento ao cliente desta forma era a maneira mais rápida de obter uma resposta. Espero que estejam certos! Qual é o prazo de devolução para uma jaqueta?"], "answer": "Nossa política de devolução permite..."},  # Caso extremo: Informação irrelevante
    # ... mais 47 FAQs
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        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 do FAQ: {similarity_score * 100}%")

O que mede: ROUGE-L (Recall-Oriented Understudy for Gisting Evaluation - Longest Common Subsequence) avalia a qualidade dos resumos gerados. Mede o comprimento da subsequência comum mais longa entre os resumos candidato e 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: 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, foi destaque na semana passada por salvar... Nas 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 esta celebridade fez! ... extensivo trabalho de caridade ...", "summary": "Trabalho extensivo de caridade da 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-20241022",
        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.

Exemplos de casos de teste: 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 então minha conta foi bloqueada...", "tone": "patient"},  # Caso extremo: Problema complexo
    {"text": "Não acredito como seu produto é bom. 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-20241022",
        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}
    Retorne apenas o número."""

    # Geralmente é melhor 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 contexto e identificar formas sutis ou implícitas de PHI que sistemas baseados em regras podem perder.

Exemplos de casos de teste: 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": "Pode me dizer por que João Silva, nascido em 12/05/1980, foi prescrito 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 foi prescrito o mesmo medicamento 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-20241022",
        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 refere-se a qualquer dado de saúde individualmente identificável que é criado, usado ou divulgado 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, a prestação de cuidados de saúde a esse indivíduo ou pagamento por tais cuidados.
    Aspectos principais de PHI incluem:
    - Identificadores: Nomes, endereços, datas de nascimento, números de Seguro Social, números de registro médico, etc.
    - Dados de saúde: Diagnósticos, planos de tratamento, resultados de testes, registros de medicação, etc.
    - Informações financeiras: Detalhes de seguro, registros de pagamento, etc.
    - Comunicação: Notas de provedores de saúde, e-mails ou mensagens sobre saúde.

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

    # Geralmente é melhor 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 refere-se a qualquer dado de saúde individualmente identificável que é criado, usado ou divulgado 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, a prestação de cuidados de saúde a esse indivíduo ou 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 de Privacidade: {sum(privacy_scores) / len(privacy_scores) * 100}%")

O que mede: Similar à 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 constrói sobre o histórico da conversa, o que é fundamental para interações coerentes e personalizadas.

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

import anthropic

conversations = [
    [
        {"role": "user", "content": "Acabei de ganhar um spitz alemão!"},
        {"role": "assistant", "content": "Parabéns pelo seu novo amigo peludo! É seu primeiro cachorro?"},
        {"role": "user", "content": "Sim, é. Dei o nome de Luna."},
        {"role": "assistant", "content": "Luna é um nome adorável! Como dono de primeira viagem, você deve ter algumas dúvidas. O que gostaria de saber sobre cuidar da Luna?"},
        ...
        {"role": "user", "content": "O que devo saber sobre cuidar de um cachorro desta raça específica?"}  # Caso extremo: Depende de contexto muito anterior
    ],
    [
        {"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 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": "Desculpe, mas não me lembro da data exata do aniversário da Scout ser mencionada em 'O Sol é para Todos'. O romance não se concentra em detalhes tão específicos. Em vez disso, centra-se no crescimento e nas experiências de Scout ao longo de vários anos. Há alguma parte específica do livro ou do desenvolvimento da Scout que você gostaria de discutir?"},
        {"role": "user", "content": "Ah, certo. Bem, pode sugerir uma receita de bolo tradicional 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-20241022",
        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
    Retorne apenas o número e nada mais."""

    # Geralmente é melhor 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 base 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 brainstorm 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 nuance 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 primeiro para garantir confiabilidade 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 mencionar, 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 retornar apenas ‘correto’ ou ‘incorreto’, ou a julgar em uma escala de 1-5. Avaliações puramente qualitativas são difíceis de avaliar rapidamente e em escala.
Encoraje o raciocínio: Peça ao LLM para pensar primeiro antes de decidir uma pontuação de avaliação, e depois descarte o raciocínio. Isso aumenta o desempenho da avaliação, particularmente para tarefas que requerem 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 em seu raciocínio em tags <thinking>, depois retorne 'correct' ou 'incorrect' 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 "correct" if "correct" in grader_response.lower() else "incorrect"

# Exemplo de uso
eval_data = [
    {"question": "42 é a resposta para a vida, o universo e tudo mais?", "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-20241022",
        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('correct') / len(grades) * 100}%")

Próximos passos

Faça 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

Aprenda sobre o Claude

Construir com Claude

Recursos

Testar e avaliar

Centro Legal

Criar avaliações empíricas fortes

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

Faça brainstorm de avaliações

Livro de receitas de avaliações

Começar

Aprenda sobre o Claude

Construir com Claude

Recursos

Testar e avaliar

Centro Legal

​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

Faça 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