Crear evaluaciones empíricas sólidas

Después de definir tus criterios de éxito, el siguiente paso es diseñar evaluaciones para medir el rendimiento del LLM frente a esos criterios. Esta es una parte vital del ciclo de ingeniería de prompts.

Esta guía se centra en cómo desarrollar tus casos de prueba.

Construyendo evaluaciones y casos de prueba

Principios de diseño de evaluaciones

Sé específico para cada tarea: Diseña evaluaciones que reflejen la distribución de tus tareas en el mundo real. ¡No olvides considerar los casos extremos!
- Datos de entrada irrelevantes o inexistentes
- Datos de entrada o entrada del usuario excesivamente largos
- [Casos de uso de chat] Entrada del usuario deficiente, dañina o irrelevante
- Casos de prueba ambiguos donde incluso a los humanos les resultaría difícil llegar a un consenso en la evaluación
Automatiza cuando sea posible: Estructura las preguntas para permitir una calificación automatizada (por ejemplo, opción múltiple, coincidencia de cadenas, calificación por código, calificación por LLM).
Prioriza el volumen sobre la calidad: Más preguntas con calificación automatizada de señal ligeramente inferior es mejor que menos preguntas con evaluaciones manuales de alta calidad calificadas por humanos.

Ejemplos de evaluaciones

Fidelidad de la tarea (análisis de sentimiento) - evaluación de coincidencia exacta

Qué mide: Las evaluaciones de coincidencia exacta miden si la salida del modelo coincide exactamente con una respuesta correcta predefinida. Es una métrica simple y sin ambigüedades que es perfecta para tareas con respuestas claras y categóricas como el análisis de sentimiento (positivo, negativo, neutral).

Ejemplos de casos de prueba: 1000 tweets con sentimientos etiquetados 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}%")

Consistencia (bot de FAQ) - evaluación de similitud de coseno

Qué mide: La similitud de coseno mide la similitud entre dos vectores (en este caso, incrustaciones de oraciones de la salida del modelo usando SBERT) calculando el coseno del ángulo entre ellos. Los valores más cercanos a 1 indican mayor similitud. Es ideal para evaluar la consistencia porque preguntas similares deberían producir respuestas semánticamente similares, incluso si la redacción varía.

Ejemplos de casos de prueba: 50 grupos con algunas versiones parafraseadas cada uno.

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

Relevancia y coherencia (resumen) - evaluación ROUGE-L

Qué mide: ROUGE-L (Recall-Oriented Understudy for Gisting Evaluation - Longest Common Subsequence) evalúa la calidad de los resúmenes generados. Mide la longitud de la subsecuencia común más larga entre los resúmenes candidato y de referencia. Las puntuaciones altas de ROUGE-L indican que el resumen generado captura información clave en un orden coherente.

Ejemplos de casos de prueba: 200 artículos con resúmenes de referencia.

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

Tono y estilo (servicio al cliente) - escala Likert basada en LLM

Qué mide: La escala Likert basada en LLM es una escala psicométrica que utiliza un LLM para juzgar actitudes o percepciones subjetivas. Aquí, se utiliza para calificar el tono de las respuestas en una escala del 1 al 5. Es ideal para evaluar aspectos matizados como la empatía, el profesionalismo o la paciencia que son difíciles de cuantificar con métricas tradicionales.

Ejemplos de casos de prueba: 100 consultas de clientes con tono objetivo (empático, profesional, 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)}")

Preservación de la privacidad (chatbot médico) - clasificación binaria basada en LLM

Qué mide: La clasificación binaria determina si una entrada pertenece a una de dos clases. Aquí, se utiliza para clasificar si una respuesta contiene PHI (información de salud protegida) o no. Este método puede entender el contexto e identificar formas sutiles o implícitas de PHI que los sistemas basados en reglas podrían pasar por alto.

Ejemplos de casos de prueba: 500 consultas simuladas de pacientes, algunas con 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}%")

Utilización del contexto (asistente de conversación) - escala ordinal basada en LLM

Qué mide: Similar a la escala Likert, la escala ordinal mide en una escala fija y ordenada (1-5). Es perfecta para evaluar la utilización del contexto porque puede capturar el grado en que el modelo hace referencia y se basa en el historial de conversación, lo cual es clave para interacciones coherentes y personalizadas.

Ejemplos de casos de prueba: 100 conversaciones de múltiples turnos con preguntas dependientes del 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)}")

¡Escribir cientos de casos de prueba puede ser difícil de hacer manualmente! Pide ayuda a Claude para generar más a partir de un conjunto base de casos de prueba de ejemplo.

Si no sabes qué métodos de evaluación podrían ser útiles para evaluar tus criterios de éxito, ¡también puedes hacer una lluvia de ideas con Claude!

Calificación de evaluaciones

Al decidir qué método usar para calificar las evaluaciones, elige el método más rápido, más confiable y más escalable:

Calificación basada en código: La más rápida y confiable, extremadamente escalable, pero también carece de matices para juicios más complejos que requieren menos rigidez basada en reglas.
- Coincidencia exacta: output == golden_answer
- Coincidencia de cadena: key_phrase in output
Calificación humana: La más flexible y de alta calidad, pero lenta y costosa. Evítala si es posible.
Calificación basada en LLM: Rápida y flexible, escalable y adecuada para juicios complejos. Prueba primero para asegurar la fiabilidad y luego escala.

Consejos para la calificación basada en LLM

Ten rúbricas detalladas y claras: “La respuesta siempre debe mencionar ‘Acme Inc.’ en la primera frase. Si no lo hace, la respuesta se califica automáticamente como ‘incorrecta’.”
Un caso de uso determinado, o incluso un criterio de éxito específico para ese caso de uso, podría requerir varias rúbricas para una evaluación holística.
Empírica o específica: Por ejemplo, instruye al LLM para que produzca solo ‘correcto’ o ‘incorrecto’, o para que juzgue en una escala del 1 al 5. Las evaluaciones puramente cualitativas son difíciles de evaluar rápidamente y a escala.
Fomenta el razonamiento: Pide al LLM que piense primero antes de decidir una puntuación de evaluación, y luego descarta el razonamiento. Esto aumenta el rendimiento de la evaluación, particularmente para tareas que requieren un juicio complejo.

Ejemplo: Calificación basada en 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 pasos

Lluvia de ideas para evaluaciones

Aprende cómo crear prompts que maximicen tus puntuaciones de evaluación.

Libro de recetas de evaluaciones

Más ejemplos de código de evaluaciones calificadas por humanos, código y LLM.

Primeros pasos

Modelos y precios

Explorar funciones

Probar y evaluar

Conoce a Claude

Centro legal

Componentes del agente

Crear evaluaciones empíricas sólidas

Construyendo evaluaciones y casos de prueba

Principios de diseño de evaluaciones

Ejemplos de evaluaciones

Calificación de evaluaciones

Consejos para la calificación basada en LLM

Próximos pasos

Lluvia de ideas para evaluaciones

Libro de recetas de evaluaciones

Primeros pasos

Modelos y precios

Explorar funciones

Probar y evaluar

Conoce a Claude

Centro legal

Componentes del agente

​Construyendo evaluaciones y casos de prueba

​Principios de diseño de evaluaciones

​Ejemplos de evaluaciones

​Calificación de evaluaciones

​Consejos para la calificación basada en LLM

​Próximos pasos

Lluvia de ideas para evaluaciones

Libro de recetas de evaluaciones

Construyendo evaluaciones y casos de prueba

Principios de diseño de evaluaciones

Ejemplos de evaluaciones

Calificación de evaluaciones

Consejos para la calificación basada en LLM

Próximos pasos