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 contra 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 la tarea: Diseña evaluaciones que reflejen la distribución de tus tareas del mundo real. ¡No olvides tener en cuenta 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 la 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 más baja es mejor que menos preguntas con evaluaciones calificadas manualmente de alta calidad.

Ejemplos de evaluaciones

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 categóricas claras 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": "Esta película fue una pérdida total de tiempo. 👎", "sentiment": "negative"},
    {"text": "¡El nuevo álbum es 🔥! Lo he tenido en repetición todo el día.", "sentiment": "positive"},
    {"text": "Me encanta cuando mi vuelo se retrasa 5 horas. #elmejordía", "sentiment": "negative"},  # Caso extremo: Sarcasmo
    {"text": "La trama de la película fue terrible, pero la actuación fue fenomenal.", "sentiment": "mixed"},  # Caso extremo: Sentimiento mixto
    # ... 996 tweets más
]

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"Clasifica esto como 'positive', 'negative', 'neutral', o '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"Precisión del Análisis de Sentimiento: {accuracy * 100}%")

Qué mide: La similitud del 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": ["¿Cuál es tu política de devoluciones?", "¿Cómo puedo devolver un artículo?", "¿Kual es tu politika de devolucions?"], "answer": "Nuestra política de devoluciones permite..."},  # Caso extremo: Errores ortográficos
    {"questions": ["Compré algo la semana pasada, y no es realmente lo que esperaba, así que me preguntaba si tal vez podría posiblemente devolverlo?", "Leí en línea que su política es de 30 días pero eso parece que podría estar desactualizado porque el sitio web se actualizó hace seis meses, así que me pregunto cuál es exactamente su política actual?"], "answer": "Nuestra política de devoluciones permite..."},  # Caso extremo: Pregunta larga y divagante
    {"questions": ["Soy el primo de Jane, y ella dijo que ustedes tienen un excelente servicio al cliente. ¿Puedo devolver esto?", "Reddit me dijo que contactar al servicio al cliente de esta manera era la forma más rápida de obtener una respuesta. ¡Espero que tengan razón! ¿Cuál es el período de devolución para una chaqueta?"], "answer": "Nuestra política de devoluciones permite..."},  # Caso extremo: Información irrelevante
    # ... 47 FAQs más
]

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"Puntuación de Consistencia FAQ: {similarity_score * 100}%")

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 ROUGE-L altas 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": "En un estudio revolucionario, investigadores del MIT...", "summary": "Científicos del MIT descubren un nuevo antibiótico..."},
    {"text": "Jane Doe, una heroína local, fue noticia la semana pasada por salvar... En noticias del ayuntamiento, el presupuesto... Los meteorólogos predicen...", "summary": "La comunidad celebra a la heroína local Jane Doe mientras la ciudad lidia con problemas presupuestarios."},  # Caso extremo: Múltiples temas
    {"text": "¡No creerás lo que hizo esta celebridad! ... extenso trabajo benéfico ...", "summary": "El extenso trabajo benéfico de la celebridad sorprende a los fans"},  # Caso extremo: Título engañoso
    # ... 197 artículos más
]

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']  # Puntuación F1 ROUGE-L

outputs = [get_completion(f"Resume este artículo en 1-2 oraciones:\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"Puntuación F1 ROUGE-L Promedio: {sum(relevance_scores) / len(relevance_scores)}")

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 usa para calificar el tono de las respuestas en una escala del 1 al 5. Es ideal para evaluar aspectos matizados como empatía, profesionalismo o 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": "Esta es la tercera vez que arruinan mi pedido. ¡Quiero un reembolso YA!", "tone": "empathetic"},  # Caso extremo: Cliente enojado
    {"text": "Intenté restablecer mi contraseña pero luego mi cuenta se bloqueó...", "tone": "patient"},  # Caso extremo: Problema complejo
    {"text": "No puedo creer lo bueno que es su producto. Ha arruinado todos los demás para mí!", "tone": "professional"},  # Caso extremo: Cumplido como queja
    # ... 97 consultas más
]

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"""Califica esta respuesta de servicio al cliente en una escala de 1-5 por ser {target_tone}:
    <response>{model_output}</response>
    1: Nada {target_tone}
    5: Perfectamente {target_tone}
    Muestra solo el número."""

    # Generalmente es mejor práctica usar un modelo diferente para evaluar que el modelo usado para generar la salida evaluada 
    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"Responde a esta consulta del cliente: {inquiry['text']}") for inquiry in inquiries]
tone_scores = [evaluate_likert(output, inquiry['tone']) for output, inquiry in zip(outputs, inquiries)]
print(f"Puntuación Promedio de Tono: {sum(tone_scores) / len(tone_scores)}")

Qué mide: La clasificación binaria determina si una entrada pertenece a una de dos clases. Aquí, se usa para clasificar si una respuesta contiene PHI 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": "¿Cuáles son los efectos secundarios del Lisinopril?", "contains_phi": False},
    {"query": "¿Puedes decirme por qué a John Doe, fecha de nacimiento 5/12/1980, le recetaron Metformina?", "contains_phi": True},  # Caso extremo: PHI explícito
    {"query": "Si mi amiga Alice, que nació el 4 de julio de 1985, tuviera diabetes, qué...", "contains_phi": True},  # Caso extremo: PHI hipotético
    {"query": "Estoy preocupado por mi hijo. Le han recetado el mismo medicamento que a su padre el año pasado.", "contains_phi": True},  # Caso extremo: PHI implícito
    # ... 496 consultas más
]

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 respuesta contiene o hace referencia a alguna Información de Salud Personal (PHI)?
    PHI se refiere a cualquier dato de salud individualmente identificable que se crea, usa o divulga en el curso de la prestación de servicios de atención médica. Esto incluye información relacionada con la condición de salud física o mental de un individuo, la provisión de atención médica a ese individuo o el pago por dicha atención.
    Aspectos clave de PHI incluyen:
    - Identificadores: Nombres, direcciones, fechas de nacimiento, números de Seguro Social, números de registro médico, etc.
    - Datos de salud: Diagnósticos, planes de tratamiento, resultados de pruebas, registros de medicamentos, etc.
    - Información financiera: Detalles de seguro, registros de pago, etc.
    - Comunicación: Notas de proveedores de atención médica, correos electrónicos o mensajes sobre salud.

    <response>{model_output}</response>
    Muestra solo 'sí' o 'no'."""

    # Generalmente es mejor práctica usar un modelo difer

ente para evaluar que el modelo usado para generar la salida evaluada
    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"Eres un asistente médico. Nunca reveles ningún PHI en tus respuestas. PHI se refiere a cualquier dato de salud individualmente identificable que se crea, usa o divulga en el curso de la prestación de servicios de atención médica. Esto incluye información relacionada con la condición de salud física o mental de un individuo, la provisión de atención médica a ese individuo o el pago por dicha atención. Aquí está la pregunta: {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"Puntuación de Preservación de Privacidad: {sum(privacy_scores) / len(privacy_scores) * 100}%")

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 la 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": "¡Acabo de conseguir un pomerania!"},
        {"role": "assistant", "content": "¡Felicitaciones por tu nuevo amigo peludo! ¿Es tu primer perro?"},
        {"role": "user", "content": "Sí, lo es. La llamé Luna."},
        {"role": "assistant", "content": "¡Luna es un nombre hermoso! Como dueño primerizo de un perro, podrías tener algunas preguntas. ¿Qué te gustaría saber sobre el cuidado de Luna?"},
        ...
        {"role": "user", "content": "¿Qué debería saber sobre el cuidado de un perro de esta raza específica?"}  # Caso extremo: Se basa en contexto de mucho antes
    ],
    [
        {"role": "user", "content": "Estoy leyendo 'Matar un ruiseñor' para mi club de lectura."},
        {"role": "assistant", "content": "¡Excelente elección! 'Matar un ruiseñor' de Harper Lee es un clásico que explora temas de injusticia racial y crecimiento moral. ¿Qué te está pareciendo hasta ahora?"},
        {"role": "user", "content": "Es poderoso. Oye, ¿cuándo era el cumpleaños de Scout?"},  # Caso extremo: Cambio abrupto de tema
        {"role": "assistant", "content": "Me disculpo, pero no recuerdo que se mencione la fecha exacta del cumpleaños de Scout en 'Matar un ruiseñor'. La novela no se centra en detalles tan específicos. En cambio, se centra en el crecimiento y las experiencias de Scout durante varios años. ¿Hay alguna parte específica del libro o del desarrollo de Scout que te interese discutir?"},
        {"role": "user", "content": "Oh, cierto. Bueno, ¿puedes sugerir una receta para un pastel sureño clásico?"}  # Caso extremo: Otro cambio de tema
    ],
    # ... 98 conversaciones más
]

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"""Califica qué tan bien esta respuesta utiliza el contexto de la conversación en una 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 el contexto
    5: Utiliza perfectamente el contexto
    Muestra solo el número y nada más."""

    # Generalmente es mejor práctica usar un modelo diferente para evaluar que el modelo usado para generar la salida evaluada
    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"Puntuación Promedio de Utilización de Contexto: {sum(context_scores) / len(context_scores)}")

¡Escribir cientos de casos de prueba puede ser difícil de hacer a mano! Haz que Claude te ayude a 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!

Calificando evaluaciones

Al decidir qué método usar para calificar 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. Evitar si es posible.
Calificación basada en LLM: Rápida y flexible, escalable y adecuada para juicios complejos. Prueba primero para asegurar la confiabilidad 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 oración. Si no lo hace, la respuesta se califica automáticamente como ‘incorrecta’.”
Un caso de uso dado, 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írico o específico: Por ejemplo, instruye al LLM para que muestre solo ‘correcto’ o ‘incorrecto’, o para que juzgue en una escala de 1-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.

import anthropic

def build_grader_prompt(answer, rubric):
    return f"""Califica esta respuesta basándote en la rúbrica:
    <rubric>{rubric}</rubric>
    <answer>{answer}</answer>
    Piensa tu razonamiento en etiquetas <thinking>, luego muestra 'correct' o 'incorrect' en etiquetas <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"

# Ejemplo de uso
eval_data = [
    {"question": "¿Es 42 la respuesta a la vida, el universo y todo?", "golden_answer": "Sí, según 'La Guía del Autoestopista Galáctico'."},
    {"question": "¿Cuál es la capital de Francia?", "golden_answer": "La capital de Francia es París."}
]

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"Puntuación: {grades.count('correct') / len(grades) * 100}%")

Siguientes pasos

Lluvia de ideas de 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.

Empezar

Construir con Claude

Aprende sobre Claude

Probar y evaluar

Administración

Centro legal

Recursos

Crear evaluaciones empíricas sólidas

Construyendo evaluaciones y casos de prueba

Principios de diseño de evaluaciones

Ejemplos de evaluaciones

Calificando evaluaciones

Consejos para la calificación basada en LLM

Siguientes pasos

Lluvia de ideas de evaluaciones

Libro de recetas de evaluaciones

Empezar

Construir con Claude

Aprende sobre Claude

Probar y evaluar

Administración

Centro legal

Recursos

​Construyendo evaluaciones y casos de prueba

​Principios de diseño de evaluaciones

​Ejemplos de evaluaciones

​Calificando evaluaciones

​Consejos para la calificación basada en LLM

​Siguientes pasos

Lluvia de ideas de evaluaciones

Libro de recetas de evaluaciones

Construyendo evaluaciones y casos de prueba

Principios de diseño de evaluaciones

Ejemplos de evaluaciones

Calificando evaluaciones

Consejos para la calificación basada en LLM

Siguientes pasos