Определите критерии успеха и постройте оценки

*Подробнее об отложенных тестовых наборах — в следующем разделе.

Насколько хорошо модель должна справляться с задачей? Возможно, стоит также подумать про обработку граничных случаев: насколько хорошо модель должна работать на редких или сложных входных данных.

Насколько похожи должны быть ответы модели на похожие типы входных данных? Если пользователь задаёт один и тот же вопрос дважды, насколько важно, чтобы он получил семантически схожие ответы?

Насколько хорошо модель напрямую отвечает на вопросы или инструкции пользователя? Насколько важно, чтобы информация была представлена логично и легко для восприятия?

Насколько стиль выходных данных модели соответствует ожиданиям? Насколько уместен её язык для целевой аудитории?

Какая метрика подходит, чтобы оценить, как модель обращается с персональной или чувствительной информацией? Может ли она следовать инструкциям не использовать и не раскрывать определённые данные?

Насколько эффективно модель использует предоставленный контекст? Насколько хорошо она ссылается на информацию из истории и опирается на неё?

Какое время ответа модели приемлемо? Это зависит от требований вашего приложения к реальному времени и ожиданий пользователей.

Каков ваш бюджет на работу модели? Учитывайте такие факторы, как стоимость API-вызова, размер модели и частота использования.

*В реальности мы бы также определили, что значит «неудобство» и «вопиющее».

Что измеряет: оценки через точное совпадение проверяют, точно ли выходные данные модели совпадают с заранее заданным правильным ответом. Это простая, однозначная метрика, идеально подходящая для задач с чёткими категориальными ответами — таких как анализ тональности (positive, negative, neutral).

Примеры тест-кейсов для оценки: 1000 твитов с размеченными людьми тональностями.

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",
    },  # Граничный случай: сарказм
    {
        "text": "The movie's plot was terrible, but the acting was phenomenal.",
        "sentiment": "mixed",
    },  # Граничный случай: смешанная тональность
    # ... ещё 996 твитов
]

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

Что измеряет: косинусное сходство измеряет схожесть между двумя векторами (в данном случае — sentence embeddings выходных данных модели, полученных через 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...",
    },  # Граничный случай: опечатки
    {
        "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...",
    },  # Граничный случай: длинный многословный вопрос
    {
        "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...",
    },  # Граничный случай: нерелевантная информация
    # ... ещё 47 FAQ
]

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

Что измеряет: ROUGE-L (Recall-Oriented Understudy for Gisting Evaluation — Longest Common Subsequence) оценивает качество сгенерированных суммари. Метрика измеряет длину наибольшей общей подпоследовательности между кандидатным и эталонным суммари. Высокие значения 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.",
    },  # Граничный случай: несколько тем
    {
        "text": "You won't believe what this celebrity did! ... extensive charity work ...",
        "summary": "Celebrity's extensive charity work surprises fans",
    },  # Граничный случай: вводящий в заблуждение заголовок
    # ... ещё 197 статей
]

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 для оценки субъективных установок или восприятий. Здесь она применяется, чтобы оценить тон ответов по шкале от 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",
    },  # Граничный случай: рассерженный клиент
    {
        "text": "I tried resetting my password but then my account got locked...",
        "tone": "patient",
    },  # Граничный случай: сложная проблема
    {
        "text": "I can't believe how good your product is. It's ruined all others for me!",
        "tone": "professional",
    },  # Граничный случай: комплимент как жалоба
    # ... ещё 97 обращений
]

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

    # Обычно лучшая практика — использовать для оценки другую модель, не ту, которая генерирует оцениваемый вывод
    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)}")

Что измеряет: бинарная классификация определяет, принадлежит ли вход к одному из двух классов. Здесь она используется, чтобы классифицировать, содержит ответ 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,
    },  # Граничный случай: явный PHI
    {
        "query": "If my friend Alice, who was born on July 4, 1985, had diabetes, what...",
        "contains_phi": True,
    },  # Граничный случай: гипотетический PHI
    {
        "query": "I'm worried about my son. He's been prescribed the same medication as his father last year.",
        "contains_phi": True,
    },  # Граничный случай: неявный PHI
    # ... ещё 496 запросов
]

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 = """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'."""

    # Обычно лучшая практика — использовать для оценки другую модель, не ту, которая генерирует оцениваемый вывод
    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}%")

Что измеряет: как и шкала Лайкерта, порядковая шкала измеряет по фиксированной упорядоченной шкале (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?",
        },  # Граничный случай: опирается на контекст из гораздо более раннего места
    ],
    [
        {
            "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?",
        },  # Граничный случай: резкая смена темы
        {
            "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?",
        },  # Граничный случай: ещё одна смена темы
    ],
    # ... ещё 98 разговоров
]

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_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."""

    # Обычно лучшая практика — использовать для оценки другую модель, не ту, которая генерирует оцениваемый вывод
    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)}")

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 "correct" in grader_response.lower() else "incorrect"


# Пример использования
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(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}%")