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 en relación con 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

Ser específico de la tarea: Diseña evaluaciones que reflejen la distribución de tareas del mundo real. ¡No olvides tener en cuenta los casos extremos!
- Datos de entrada irrelevantes o inexistentes
- Datos de entrada o entrada de usuario excesivamente largos
- [Casos de uso de chat] Entrada de usuario pobre, dañina o irrelevante
- Casos de prueba ambiguos donde incluso los humanos tendrían dificultades para llegar a un consenso de evaluación
Automatizar 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).
Priorizar el volumen sobre la calidad: Es mejor tener más preguntas con evaluaciones automatizadas de señal ligeramente más baja que menos preguntas con evaluaciones manuales de alta calidad.

Ejemplos de evaluaciones

Lo que 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).

Ejemplo de casos de prueba de evaluación: 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 estado escuchando en repetición todo el día.", "sentiment": "positive"},
    {"text": "Me encanta cuando mi vuelo se retrasa 5 horas. #mejordíadetodos", "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-20240620",
        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}%")

Lo que mide: La similitud coseno mide la similitud entre dos vectores (en este caso, embeddings de oraciones de la salida del modelo usando SBERT) calculando el coseno del ángulo entre ellos. Los valores más cercanos a 1 indican una 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.

Ejemplo de casos de prueba de evaluación: 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 su política de devoluciones?", "¿Cómo puedo devolver un artículo?", "¿Cuál es su política de devoluciones?"], "answer": "Nuestra política de devoluciones permite..."},  # Caso extremo: Errores tipográficos
    {"questions": ["Compré algo la semana pasada y realmente no es lo que esperaba, así que me preguntaba si tal vez podría devolverlo.", "Leí en línea que su política es de 30 días, pero eso parece 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 plazo de devolución para una chaqueta?"], "answer": "Nuestra política de devoluciones permite..."},  # Caso extremo: Información irrelevante
    # ... 47 preguntas frecuentes más
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        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"Puntaje de Consistencia de Preguntas Frecuentes: {similarity_score * 100}%")

Lo que 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 candidatos y de referencia. Los puntajes altos de ROUGE-L indican que el resumen generado captura información clave en un orden coherente.

Ejemplo de casos de prueba de evaluación: 200 artículos con resúmenes de referencia.

from rouge import Rouge
import anthropic

articles = [
    {"text": "En un estudio innovador, 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 de caridad ...", "summary": "El extenso trabajo de caridad de la celebridad sorprende a los fanáticos"},  # 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-20240620",
        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']  # Puntaje F1 de 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"Puntaje F1 Promedio de ROUGE-L: {sum(relevance_scores) / len(relevance_scores)}")

Lo que 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 la empatía, el profesionalismo o la paciencia que son difíciles de cuantificar con métricas tradicionales.

Ejemplo de casos de prueba de evaluación: 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 AHORA!", "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: Elogio como queja
    # ... 97 consultas más
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        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 atención al cliente en una escala del 1 al 5 por ser {target_tone}:
    <response>{model_output}</response>
    1: Para nada {target_tone}
    5: Perfectamente {target_tone}
    Responde solo con el número."""

    # Generalmente es mejor usar un modelo diferente para evaluar que el modelo utilizado 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"Puntaje Promedio de Tono: {sum(tone_scores) / len(tone_scores)}")

Lo que 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.

Ejemplo de casos de prueba de evaluación: 500 consultas de pacientes simuladas, 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, nacido el 12/5/1980, se le recetó 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 recetaron 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-20240620",
        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, utiliza 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 prestación de atención médica a ese individuo o el pago de dicha atención.
    Los aspectos clave de PHI incluyen:
    - Identificadores: Nombres, direcciones, fechas de nacimiento, números de seguro social, números de historia clínica, etc.
    - Datos de salud: Diagnósticos, planes de tratamiento, resultados de pruebas, registros de medicamentos, etc.
    - Información financiera: Detalles del 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>
    Responde solo con 'sí' o 'no'."""

    # Generalmente es mejor usar un modelo diferente para evaluar que el modelo utilizado 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 ninguna PHI en tus respuestas. PHI se refiere a cualquier dato de salud individualmente identificable que se crea, utiliza 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 prestación de atención médica a ese individuo o el pago de 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"Puntaje de Preservación de la Privacidad: {sum(privacy_scores) / len(privacy_scores) * 100}%")

Lo que 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.

Ejemplo de casos de prueba de evaluación: 100 conversaciones de varios turnos con preguntas dependientes del contexto.

import anthropic

conversations = [
    [
        {"role": "user", "content": "¡Acabo de conseguir un nuevo pomerania!"},
        {"role": "assistant", "content": "¡Felicidades 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 encantador! Como dueño primerizo de un perro, es posible que tengas algunas preguntas. ¿Qué te gustaría saber sobre el cuidado de Luna?"},
        ...
        {"role": "user", "content": "¿Qué debo saber sobre el cuidado de un perro de esta raza específica?"}  # Caso extremo: Se basa en el contexto de mucho antes
    ],
    [
        {"role": "user", "content": "Estoy leyendo 'Matar a un ruiseñor' para mi club de lectura."},
        {"role": "assistant", "content": "¡Excelente elección! 'Matar a un ruiseñor' de Harper Lee es un clásico que explora temas de injusticia racial y crecimiento moral. ¿Qué te parece 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 a 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 a lo largo de varios años. ¿Hay alguna parte en particular del libro o del desarrollo de Scout que te interese discutir?"},
        {"role": "user", "content": "Oh, cierto. Bueno, ¿puedes sugerir una receta para un pastel clásico del sur?"}  # 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-20240620",
        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 del 1 al 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
    Responde solo con el número y nada más."""

    # Generalmente es mejor usar un modelo diferente para evaluar que el modelo utilizado 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"Puntaje Promedio de Utilización del 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 ejemplos de casos de prueba.

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 las evaluaciones, elige el método más rápido, confiable y 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. Probar para garantizar la confiabilidad primero y luego escalar.

Consejos para la calificación basada en LLM

Tener 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 integral.
Empírico o específico: Por ejemplo, instruye al LLM para que responda solo con ‘correcto’ o ‘incorrecto’, o que juzgue en una escala del 1 al 5. Las evaluaciones puramente cualitativas son difíciles de evaluar rápidamente y a escala.
Fomentar el razonamiento: Pide al LLM que piense primero antes de decidir un puntaje de evaluación, y luego descarte 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 según la rúbrica:
    <rubric>{rubric}</rubric>
    <answer>{answer}</answer>
    Piensa tu razonamiento entre etiquetas <thinking>, luego responde con 'correcto' o 'incorrecto' entre 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 "correcto" if "correcto" in grader_response.lower() else "incorrecto"

# Ejemplo de uso
eval_data = [
    {"question": "¿Es 42 la respuesta a la vida, el universo y todo lo demás?", "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-20240620",
        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"Puntaje: {grades.count('correcto') / len(grades) * 100}%")

Próximos pasos

Hacer una lluvia de ideas de evaluaciones

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

Recetario de evaluaciones

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

Comenzar

Aprender sobre Claude

Construir con Claude

Probar y evaluar

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

Próximos pasos

Hacer una lluvia de ideas de evaluaciones

Recetario de evaluaciones

Comenzar

Aprender sobre Claude

Construir con Claude

Probar y evaluar

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

​Próximos pasos

Hacer una lluvia de ideas de evaluaciones

Recetario 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

Próximos pasos