定义成功标准并构建评估

构建成功的 LLM 应用程序，首先要明确定义成功标准，然后设计评估来衡量性能表现。这个循环是提示词工程的核心。

定义成功标准

好的成功标准应具备以下特征：

• 具体： 明确定义你想要达成的目标。不要使用"良好性能"，而要具体说明"准确的情感分类"。
• 可量化： 使用定量指标或明确定义的定性量表。数字能提供清晰度和可扩展性，但如果始终与定量指标配合使用，定性衡量也可以很有价值。
  • 即使是"模糊"的主题，如伦理和安全，也可以量化：

    	安全标准
    差	安全的输出
    优	在 10,000 次试验中，少于 0.1% 的输出被我们的内容过滤器标记为有害。

示例指标和衡量方法

定量指标：

• 任务特定：F1 分数、BLEU 分数、困惑度
• 通用：准确率、精确率、召回率
• 运维：响应时间（毫秒）、正常运行时间（%）

定量方法：

• A/B 测试：与基线模型或早期版本进行性能对比。
• 用户反馈：如任务完成率等隐式度量。
• 边界用例分析：无错误处理的边界用例百分比。

定性量表：

• 李克特量表："对连贯性进行 1（毫无意义）到 5（完全合乎逻辑）的评分"

• 专家评分标准：语言学家根据定义的标准对翻译质量进行评分

• 可实现： 基于行业基准、先前实验、AI 研究或专家知识来设定目标。你的成功指标不应超出当前前沿模型能力的现实范围。

• 相关： 将标准与应用程序的目的和用户需求保持一致。引用准确性对于医疗应用可能至关重要，但对于休闲聊天机器人则不那么重要。

情感分析的任务保真度标准示例

*更多关于留出测试集的内容请参见下一节。

常见成功标准

以下是一些对你的用例可能很重要的标准。此列表并非详尽无遗。

任务保真度

模型在任务上的表现需要达到什么水平？你可能还需要考虑边界用例处理，例如模型在罕见或困难输入上的表现。

一致性

模型对相似类型输入的回复需要有多相似？如果用户两次提出相同问题，获得语义相似的答案有多重要？

相关性和连贯性

模型直接回答用户问题或指令的效果如何？信息以逻辑清晰、易于理解的方式呈现有多重要？

语气和风格

模型的输出风格与期望的匹配程度如何？其语言对目标受众的适当性如何？

隐私保护

模型处理个人或敏感信息的成功指标是什么？它能否遵循指令不使用或分享某些细节？

上下文利用

模型使用所提供上下文的效果如何？它引用和基于历史信息进行构建的能力如何？

延迟

模型的可接受响应时间是多少？这取决于应用程序的实时需求和用户期望。

价格

运行模型的预算是多少？考虑因素包括每次 API 调用的成本、模型大小和使用频率。

大多数用例需要沿多个成功标准进行多维度评估。

情感分析的多维度标准示例

*在实际中，我们还需要定义"不便"和"严重"的含义。

构建评估

评估设计原则

1. 针对任务设计： 设计反映实际任务分布的评估。不要忘记考虑边界用例！

边界用例示例

• 无关或不存在的输入数据
• 过长的输入数据或用户输入
• [聊天用例] 不良、有害或无关的用户输入
• 即使人类也难以达成评估共识的模糊测试用例

2. 尽可能自动化： 结构化问题以便自动评分（例如，选择题、字符串匹配、代码评分、LLM 评分）。
3. 优先数量而非质量： 更多问题配合稍低信噪比的自动评分，比更少问题配合高质量人工评分更好。

评估示例

任务保真度（情感分析）- 精确匹配评估

衡量内容：精确匹配评估衡量模型的输出是否与预定义的正确答案匹配，通常在规范化空白和大小写后进行。这是一个简单、明确的指标，非常适合有明确分类答案的任务，如情感分析（正面、负面、中性）。

评估测试用例示例：1,000 条带有人工标注情感的推文。

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-7",
        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}%")

一致性（FAQ 机器人）- 余弦相似度评估

衡量内容：余弦相似度通过计算两个向量之间的夹角余弦值来衡量它们的相似度（在此情况下，是使用 Sentence-BERT (SBERT) 对模型输出进行的句子嵌入）。值越接近 1 表示相似度越高。它非常适合评估一致性，因为相似的问题应该产生语义相似的答案，即使措辞不同。

评估测试用例示例：50 组，每组包含几个改写版本。

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-7",
        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(outputs)

    norms = np.linalg.norm(embeddings, axis=1)
    cosine_similarities = np.dot(embeddings, embeddings.T) / np.outer(norms, norms)
    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}%")

相关性和连贯性（摘要生成）- ROUGE-L 评估

衡量内容：ROUGE-L（面向召回的摘要评估 - 最长公共子序列）评估生成摘要的质量。它衡量候选摘要和参考摘要之间最长公共子序列的长度。高 ROUGE-L 分数表明生成的摘要以连贯的顺序捕获了关键信息。

评估测试用例示例：200 篇带参考摘要的文章。

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-7",
        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)}")

语气和风格（客服）- 基于 LLM 的李克特量表

衡量内容：基于 LLM 的李克特量表是一种心理测量量表，使用 LLM 来判断主观态度或感知。在此，它用于对回复的语气进行 1 到 5 分的评分。它非常适合评估难以用传统指标量化的细微方面，如同理心、专业性或耐心。

评估测试用例示例：100 条带有目标语气（有同理心、耐心、专业）的客户咨询。

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-7",
        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-opus-4-7",
        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)}")

隐私保护（医疗聊天机器人）- 基于 LLM 的二分类

衡量内容：二分类确定输入是否属于两个类别之一。在此，它用于分类回复是否包含 PHI（个人健康信息）。此方法能够理解上下文并识别基于规则的系统可能遗漏的细微或隐式 PHI。

评估测试用例示例：500 个模拟的患者查询，其中一些包含 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-7",
        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 = f"""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-opus-4-7",
        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}%")

上下文利用（对话助手）- 基于 LLM 的序数量表

衡量内容：与李克特量表类似，序数量表在固定的有序量表（1-5）上进行衡量。它非常适合评估上下文利用，因为它可以捕获模型引用和基于对话历史进行构建的程度，这是连贯、个性化交互的关键。

评估测试用例示例：100 个包含上下文相关问题的多轮对话。

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(conversation: list):
    message = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=1024,
        messages=conversation,
    )
    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-opus-4-7",
        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)}")

对评估进行评分

在决定使用哪种方法对评估进行评分时，选择最快、最可靠、最具可扩展性的方法：

1. 基于代码的评分： 最快且最可靠，极具可扩展性，但对于需要较少规则化刚性的复杂判断缺乏细微性。

   • 精确匹配：output == golden_answer
   • 字符串匹配：key_phrase in output

2. 人工评分： 最灵活且质量最高，但速度慢且成本高。尽可能避免使用。

3. 基于 LLM 的评分： 快速灵活，可扩展且适合复杂判断。先测试确保可靠性，然后再扩展。

基于 LLM 评分的技巧

• 制定详细、清晰的评分标准： "答案应始终在第一句中提及 'Acme Inc.'。如果没有，答案自动评为'不正确'。"
  ℹ️

  Note

  一个给定的用例，甚至该用例的某个特定成功标准，可能需要多个评分标准来进行全面评估。
• 经验性或具体化： 例如，指示 LLM 仅输出 'correct' 或 'incorrect'，或从 1-5 的量表中判断。纯定性评估难以快速且大规模地评估。
• 鼓励推理： 要求 LLM 在决定评估分数之前先进行思考，然后丢弃推理过程。这可以提高评估性能，特别是对于需要复杂判断的任务。

示例：基于 LLM 的评分

import anthropic

client = anthropic.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-opus-4-7",
            max_tokens=2048,
            messages=[
                {"role": "user", "content": build_grader_prompt(output, golden_answer)}
            ],
        )
        .content[0]
        .text
    )

    return (
        "correct"
        if "<result>correct</result>" 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-7",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}],
    )
    return message.content[0].text


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

后续步骤