Saltar al contenido principal

Evalúa eficazmente los LLM con DeepEval: Guía práctica

Aprende a utilizar DeepEval para crear pruebas de relevancia similares a las de Pytest, a evaluar los resultados de LLM con la métrica G-eval y a comparar Qwen 2.5 con MMLU.
Actualizado 15 ene 2025  · 35 min de lectura

Hay pocos marcos de evaluación disponibles en el ecosistema del aprendizaje automático que puedan probar eficazmente los grandes modelos lingüísticos (LLM) en función de varias propiedades. Con el crecimiento exponencial del desarrollo de los LLM, se ha vuelto crucial evaluar su rendimiento en diversas tareas y valorar sus puntos fuertes, sus puntos débiles y sus limitaciones. 

DeepEval se presenta como una solución completa y fiable para abordar esta necesidad, ofreciendo un marco sólido para probar los LLM en múltiples dimensiones, como la precisión, el razonamiento, la coherencia y la alineación ética.

En este tutorial, aprenderás a configurar DeepEval y a crear una prueba de relevancia similar al enfoque de Pytest. A continuación, comprobarás los resultados del LLM utilizando la métrica G-eval y ejecutarás la evaluación comparativa MMLU en el modelo Qwen 2.5. Este es un tutorial sencillo para principiantes, dirigido a cualquier persona con conocimientos técnicos que quiera comprender mejor el ecosistema de DeepEval.

Si eres nuevo en los LLM, te recomiendo encarecidamente que sigas el curso Conceptos de los Grandes Modelos Lingüísticos (LLM) para aprender lo básico.

Comprender DeepEval

DeepEval es un marco de evaluación de código abierto diseñado específicamente para grandes modelos lingüísticos, que permite a los desarrolladores crear, mejorar, probar y supervisar eficazmente aplicaciones basadas en LLM. Simplifica el proceso de evaluación de los resultados del LLM permitiendo a los usuarios "probar por unidades" sus modelos, de forma muy parecida al uso de Pytest para las pruebas de software tradicionales.

DeepEval ofrece una amplia gama de funciones para garantizar una evaluación exhaustiva, incluidas 14 métricas de evaluación de LLM respaldadas por la investigación, generación de conjuntos de datos sintéticos, puntos de referencia de LLM, equipo rojo y evaluaciones en tiempo real en producción. Con estas funciones, DeepEval no sólo agiliza las pruebas, sino que también garantiza la seguridad y fiabilidad de las aplicaciones impulsadas por LLM.

Lee el blog Evaluación de LLM para aprender a evaluar grandes modelos lingüísticos utilizando métricas clave, metodologías y mejores prácticas.

Conceptos de Inteligencia Artificial (IA) en Python

Empieza con la IA
Empieza ahora

Primeros pasos con DeepEval

Para este tutorial, utilizaremos Kaggle como entorno de codificación. Para empezar, crea una libreta nueva. 

También utilizaremos la API OpenAI. Para continuar, crea una clave API. A continuación, configura la variable de entorno para la clave API de OpenAI utilizando la función "Secretos" de Kaggle.

Acceder a los secretos de los cuadernos Kaggle.

Después, instala la libertad de Python de DeepEval y BitsandBytes utilizando el comando pip:

%%capture
%pip install -U deepeval
%pip install -U bitsandbytes

Carga la clave de la API de OpenAI desde secretos:

import os
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_value_0 = user_secrets.get_secret("OPENAI_API_KEY")

os.environ['OPENAI_API_KEY'] = secret_value_0

Escribe el siguiente archivo Python utilizando la función mágica de Jupyter Notebook. 

El archivo test_relevancy.py define una función de prueba que evalúa la relevancia de la salida de un LLM utilizando el modelo GPT-4o. Lo hace comparando la respuesta del modelo a una entrada dada con un contexto de recuperación, asegurándose de que la salida se ajusta a la información proporcionada.

%%file test_relevancy.py
from deepeval import assert_test
from deepeval.test_case import LLMTestCase
from deepeval.metrics import AnswerRelevancyMetric


def test_relevancy():
    relevancy_metric = AnswerRelevancyMetric(threshold=0.5, model="gpt-4o")
    test_case_1 = LLMTestCase(
        input="Can I return these shoes after 30 days?",
        actual_output="Unfortunately, returns are only accepted within 30 days of purchase.",
        retrieval_context=[
            "All customers are eligible for a 30-day full refund at no extra cost.",
            "Returns are only accepted within 30 days of purchase.",
        ],
    )
    assert_test(test_case_1, [relevancy_metric])

Ejecuta la prueba de relevancia en el terminal:

!deepeval test run test_relevancy.py

El siguiente resultado de la prueba muestra que el caso de prueba LLM ha superado con éxito la prueba y ha obtenido una puntuación de relevancia perfecta de 1,0, lo que indica que la respuesta del modelo era completamente relevante. 

La evaluación se completó en 3,04 segundos con un coste total estimado del token de 0,0027425 USD:

Evaluating 1 test case(s) in parallel: |█|100% (1/1) [Time Taken: 00:03,  3.00s/
.Running teardown with pytest sessionfinish...

============================= slowest 10 durations =============================
3.03s call     test_relevancy.py::test_relevancy

(2 durations < 0.005s hidden.  Use -vv to show these durations.)
1 passed, 2 warnings in 3.04s
                                  Test Results                                  
┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃                ┃                 ┃                ┃        ┃ Overall Success ┃
┃ Test case     ┃ Metric         ┃ Score         ┃ Status ┃ Rate           ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ test_relevancy │                 │                │        │ 100.0%          │
│                │ Answer          │ 1.0            │ PASSED │                 │
│                │ Relevancy       │ (threshold=0.... │        │                 │
│                │                 │ evaluation     │        │                 │
│                │                 │ model=gpt-4o,  │        │                 │
│                │                 │ reason=The     │        │                 │
│                │                 │ score is 1.00  │        │                 │
│                │                 │ because the    │        │                 │
│                │                 │ response was   │        │                 │
│                │                 │ perfectly      │        │                 │
│                │                 │ relevant and   │        │                 │
│                │                 │ addressed the  │        │                 │
│                │                 │ question       │        │                 │
│                │                 │ directly       │        │                 │
│                │                 │ without any    │        │                 │
│                │                 │ irrelevant     │        │                 │
│                │                 │ information.   │        │                 │
│                │                 │ Great job!,    │        │                 │
│                │                 │ error=None)    │        │                 │
└────────────────┴─────────────────┴────────────────┴────────┴─────────────────┘
Total estimated evaluation tokens cost: 0.0027425 USD
✓ Tests finished 🎉! Run 'deepeval login' to save and analyze evaluation results
on Confident AI. 
‼️  Friendly reminder 😇: You can also run evaluations with ALL of deepeval's 
metrics directly on Confident AI instead.
 

También puedes evaluar a los LLM utilizando los ecosistemas de Cara Abrazada siguiendo el enlace HumanEval: Un punto de referencia para evaluar las capacidades de generación de código LLM guide.

Probar el LLM con la métrica G-Eval

G-Eval es un marco de evaluación de LLM que utiliza el razonamiento de la cadena de pensamiento (CoT) para evaluar los resultados de LLM basándose en criterios personalizados. Como métrica más adaptable de DeepEval, G-Eval puede manejar casi cualquier caso de uso con una precisión similar a la humana, lo que la convierte en una herramienta esencial para evaluar el rendimiento de los LLM.

En esta sección, evaluaremos el conjunto de datos de respuestas LLM utilizando la métrica G-Eval.

1. Configuración de la métrica G-Eval

Crearemos la métrica G-eval y proporcionaremos la instrucción personalizada para probar el reposo del modelo ante las contradicciones fácticas, penalizar las omisiones y concentrarse en la idea principal, tolerando al mismo tiempo el lenguaje vago o las opiniones divergentes:

from deepeval.metrics import GEval
from deepeval.test_case import LLMTestCaseParams
correctness_metric = GEval(
    name="Correctness",
    model="gpt-4o",
    evaluation_params=[
        LLMTestCaseParams.EXPECTED_OUTPUT,
        LLMTestCaseParams.ACTUAL_OUTPUT],
    evaluation_steps=[
        "Check whether the facts in 'actual output' contradicts any facts in 'expected output'",
        "You should also lightly penalize omission of detail, and focus on the main idea",
        "Vague language, or contradicting OPINIONS, are OK"
    ],
)

2. Crear casos de prueba para la evaluación

Crea tres casos de prueba LLM sobre temas diferentes. Cada caso de prueba tiene una pregunta de entrada, una salida real generada y una salida esperada. El modelo GPT-4o los comparará y generará resultados detallados al final:

from deepeval.test_case import LLMTestCase
from deepeval.dataset import EvaluationDataset


first_test_case = LLMTestCase(input="What are the main causes of deforestation?",
                              actual_output="The main causes of deforestation include agricultural expansion, logging, infrastructure development, and urbanization.",
                              expected_output="The main causes of deforestation include agricultural expansion, logging, infrastructure development, and urbanization.")


second_test_case = LLMTestCase(input="Define the term 'artificial intelligence'.",
                               actual_output="Artificial intelligence is the simulation of human intelligence by machines.",
                               expected_output="Artificial intelligence refers to the simulation of human intelligence in machines that are programmed to think and learn like humans, including tasks such as problem-solving, decision-making, and language understanding.")


third_test_case = LLMTestCase(input="List the primary colors.",
                              actual_output="The primary colors are green, orange, and purple.",
                              expected_output="The primary colors are red, blue, and yellow.")

3. Construir el conjunto de datos de evaluación

Crearemos el conjunto de datos de evaluación combinando los tres casos de prueba:

test_cases = [first_test_case, second_test_case, third_test_case]

dataset = EvaluationDataset(test_cases=test_cases)

4. Ejecutar la métrica G-Eval

Ejecuta la prueba de evaluación G-Eval en el conjunto de datos: 

evaluation_output = dataset.evaluate([correctness_metric])

Salida:

Los resultados de cada prueba vienen con un resumen de métricas, un caso de prueba y un resultado global de aprobación de métricas.

Evaluating 3 test case(s) in parallel: |██████████|100% (3/3) [Time Taken: 00:02,  1.08test case/s]
======================================================================

Metrics Summary

  - ✅ Correctness (GEval) (score: 1.0, threshold: 0.5, strict: False, evaluation model: gpt-4o, reason: The actual output matches the expected output exactly with no contradictions or omissions., error: None)

For test case:

  - input: What are the main causes of deforestation?
  - actual output: The main causes of deforestation include agricultural expansion, logging, infrastructure development, and urbanization.
  - expected output: The main causes of deforestation include agricultural expansion, logging, infrastructure development, and urbanization.
  - context: None
  - retrieval context: None

======================================================================

Metrics Summary

  - ✅ Correctness (GEval) (score: 0.7, threshold: 0.5, strict: False, evaluation model: gpt-4o, reason: The main idea of AI as the simulation of human intelligence is present, but details like problem-solving, decision-making, and language understanding are omitted., error: None)

For test case:

  - input: Define the term 'artificial intelligence'.
  - actual output: Artificial intelligence is the simulation of human intelligence by machines.
  - expected output: Artificial intelligence refers to the simulation of human intelligence in machines that are programmed to think and learn like humans, including tasks such as problem-solving, decision-making, and language understanding.
  - context: None
  - retrieval context: None

======================================================================

Metrics Summary

  - ❌ Correctness (GEval) (score: 0.01681606382274469, threshold: 0.5, strict: False, evaluation model: gpt-4o, reason: The actual output directly contradicts the expected output by listing green, orange, and purple as primary colors instead of red, blue, and yellow., error: None)

For test case:

  - input: List the primary colors.
  - actual output: The primary colors are green, orange, and purple.
  - expected output: The primary colors are red, blue, and yellow.
  - context: None
  - retrieval context: None

======================================================================

Overall Metric Pass Rates

Correctness (GEval): 66.67% pass rate

======================================================================
 

Aprende a evaluar LLMs con una herramienta favorita, MLflow, siguiendo el tutorial Evaluar LLMs con MLflow.

5. Analizar los resultados de los casos de prueba

La evaluación de tres casos de prueba mediante la métrica G-Eval alcanzó un porcentaje de aprobados del 66,67%, con una coincidencia perfecta, una coincidencia parcial por falta de detalles y un fallo causado por una contradicción directa. Esto pone de manifiesto los puntos fuertes del modelo en cuanto a la precisión de los hechos, pero también sus limitaciones a la hora de manejar resultados matizados o detallados.

Evaluación comparativa MMLU Qwen 2.5

MMLU (Massive Multitask Language Understanding) es un punto de referencia muy utilizado para evaluar grandes modelos lingüísticos mediante preguntas de opción múltiple. Abarca 57 materias diversas, como matemáticas, historia, derecho y ética, lo que la convierte en una prueba exhaustiva de los conocimientos y la capacidad de razonamiento de un LLM. Debido a su amplia cobertura temática y a la alta calidad de sus preguntas, el MMLU se ha convertido en un estándar para evaluar el rendimiento en LLM.

Daremos un paso más y evaluaremos nuestro LLM personalizado (Qwen 2.5 7B) en el conjunto de datos MMLU. El conjunto de datos contiene preguntas de entrada y resultados (A, B, C, D). Al final, utiliza la puntuación de las respuestas correctas para generar un porcentaje de precisión.

1. Crear la clase modelo LLM personalizada

Definiremos una clase personalizada llamada QwenModel que extiende DeepEvalBaseLLM para generar respuestas utilizando el modelo de lenguaje y el tokenizador. 

Nuestro objetivo es producir salidas cortas de dos fichas a partir de una indicación dada. Además, gestionaremos la asignación de dispositivos y nos encargaremos del preprocesamiento del texto de entrada y salida.

from deepeval.models.base_model import DeepEvalBaseLLM
import torch, logging 
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

class QwenModel(DeepEvalBaseLLM):
    def __init__(self, model, tokenizer):
        self.model = model
        self.tokenizer = tokenizer
        self.device = "cuda"

    def load_model(self):
        return self.model

    def generate(self, prompt: str) -> str:
        prompt = prompt.replace("Output 'A', 'B', 'C', or 'D'. Full answer not needed.","")
        model_inputs = self.tokenizer([prompt], return_tensors="pt").to(self.device)
        generated_ids = self.model.generate(
            **model_inputs,
            max_new_tokens=2,
            do_sample=True,
            pad_token_id=self.tokenizer.eos_token_id
        )
        prompt_length = len(model_inputs[0])
        generated_tokens = generated_ids[0][prompt_length:]
        clean_output = tokenizer.decode(generated_tokens, skip_special_tokens=True).strip()
        return clean_output.replace(".","")

    async def a_generate(self, prompt: str) -> str:
        return self.generate(prompt)

    def get_model_name(self):
        return "Qwen2.5 7B"

2. Cargar el modelo y el tokenizador

Crearemos las dos funciones que cargan el modelo LLM y el tokenizador directamente desde el local. Cargamos el modelo en 8 bits e inicializamos un tokenizador para el mismo modelo, estableciendo el relleno y las configuraciones especiales de los tokens:

def load_model(model_name: str):
    quant_config = BitsAndBytesConfig(
        load_in_8bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.float16,
        bnb_4bit_use_double_quant=False
    )
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        quantization_config=quant_config,
        device_map="auto"
    )
    model.config.use_cache = False
    model.config.pretraining_tp = 1
    return model

def load_tokenizer(model_name):
    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
    tokenizer.pad_token = tokenizer.eos_token
    tokenizer.padding_side = "right"
    return tokenizer

3. Construir el LLM personalizado

Añade el modelo de instrucción Qwen 2.4 7b al cuaderno Kaggle utilizando el botón "+ Añadir entrada".

Añadir el modelo Qwen 2.5 en el cuaderno Kaggle.

Utiliza el modelo directamente para cargar el modelo y el token, y luego proporciónalo a la clase LLM personalizada para crear un generador de respuestas LLM:

# Load model and tokenizer
qwen_model_name = "/kaggle/input/qwen2.5/transformers/7b-instruct/1"
model = load_model(qwen_model_name)
tokenizer = load_tokenizer(qwen_model_name)
custom_model = QwenModel(model, tokenizer)

4. Probar el LLM personalizado

Prueba el LLM personalizado antes de generar los resultados de la evaluación comparativa:

# Test model generation

prompt = """
The following are multiple choice questions (with answers) about abstract algebra.

Find all c in Z_3 such that Z_3[x]/(x^2 + c) is a field.
A. 0
B. 1
C. 2
D. 3
Answer:"""
print(custom_model.generate(prompt))

Proporcionamos a la LLM un ejemplo de pregunta del conjunto de datos, y respondió correctamente con una letra.

C
 

5.  Ejecutar el punto de referencia MMLU

Ahora, cargaremos el banco de pruebas MMLU, definiremos las tareas y, a continuación, ejecutaremos el banco de pruebas en el modelo personalizado: 

from deepeval.benchmarks import MMLU
from deepeval.benchmarks.tasks import MMLUTask

# Define benchmark with specific tasks and shots
benchmark = MMLU(
    tasks=[MMLUTask.HIGH_SCHOOL_COMPUTER_SCIENCE, MMLUTask.ASTRONOMY],
    n_shots=5
)

benchmark.evaluate(model=custom_model, batch_size=5)

Obtuvimos excelentes resultados, ¡con un 83% de precisión!

Processing astronomy: 100%|██████████| 152/152 [01:51<00:00,  1.36it/s]
MMLU Task Accuracy (task=astronomy): 0.8157894736842105
Overall MMLU Accuracy: 0.8293650793650794
 

Repasemos los resultados de cada tarea individual:

benchmark.task_scores

Resultados de la evaluación comparativa MMLU basados en las tareas

También puedes consultar los resultados completos, que muestran qué muestra obtuvo el resultado correcto y cuál falló. Esto proporciona un análisis granular del rendimiento del modelo.

benchmark.predictions

Resultados de la predicción del punto de referencia MMLU.

Si tienes algún problema al ejecutar el código anterior, consulta el cuaderno de Kaggle Evaluación de LLMs con DeepEval . Contiene fuentes de código, conjuntos de datos y resultados de evaluación.

Conclusión

Evaluar modelos lingüísticos puede ser un reto, sobre todo en un entorno de producción. A veces, las simples métricas de evaluación no son suficientes. Es esencial ejecutar un conjunto de puntos de referencia y pruebas para evaluar el rendimiento de tu LLM en diversas tareas y funciones, a fin de obtener una comprensión global e identificar áreas de mejora.

En este tutorial, configuramos DeepEval en un cuaderno Kaggle y realizamos pruebas LLM similares a Pytests. A continuación construimos G-Eval utilizando instrucciones personalizadas y lo ejecutamos en el conjunto de datos de evaluación. Por último, probamos el modelo Qwen 2.5 7B con el punto de referencia de evaluación MMLU para analizar su rendimiento en informática y astronomía de enseñanza secundaria.

El siguiente paso en tu viaje de aprendizaje es explorar las herramientas y metodologías LLMOps y aprender a desplegar un LLM fácilmente en producción. Para obtener más información, considera la posibilidad de seguir el curso Conceptos LLMOps.

Desarrollar aplicaciones de IA

Aprende a crear aplicaciones de IA utilizando la API OpenAI.

Abid Ali Awan's photo
Author
Abid Ali Awan
LinkedIn
Twitter

Soy un científico de datos certificado que disfruta creando aplicaciones de aprendizaje automático y escribiendo blogs sobre ciencia de datos. Actualmente me centro en la creación de contenidos, la edición y el trabajo con grandes modelos lingüísticos.

Temas

¡Aprende más sobre los LLM con estos cursos!

curso

Large Language Models (LLMs) Concepts

2 hr
40.6K
Discover the full potential of LLMs with our conceptual course covering LLM applications, training methodologies, ethical considerations, and latest research.
Ver detallesRight Arrow
Comienza el curso
Ver másRight Arrow
Relacionado

blog

Evaluación de un LLM: Métricas, metodologías y buenas prácticas

Aprende a evaluar grandes modelos lingüísticos (LLM) utilizando métricas clave, metodologías y mejores prácticas para tomar decisiones informadas.
Stanislav Karzhev's photo

Stanislav Karzhev

9 min

tutorial

Guía para principiantes de LlaMA-Factory WebUI: Ajuste de los LLM

Aprende a afinar los LLM en conjuntos de datos personalizados, evaluar el rendimiento y exportar y servir modelos sin problemas utilizando el marco de trabajo de bajo/ningún código de LLaMA-Factory.
Abid Ali Awan's photo

Abid Ali Awan

12 min

tutorial

Tutorial de DeepChecks: Automatizar las pruebas de aprendizaje automático

Aprende a realizar la validación de datos y modelos para garantizar un sólido rendimiento del aprendizaje automático utilizando nuestra guía paso a paso para automatizar las pruebas con DeepChecks.
Abid Ali Awan's photo

Abid Ali Awan

12 min

tutorial

Guía introductoria para el ajuste preciso de los LLM

El ajuste preciso de los grandes modelos lingüísticos (LLM) ha revolucionado el procesamiento del lenguaje natural (PLN) y ofrece capacidades sin precedentes en tareas como la traducción lingüística, el análisis del sentimiento y la generación de textos. Este enfoque transformador aprovecha modelos preentrenados como el GPT-2 y mejora su rendimiento en dominios específicos mediante el proceso de ajuste preciso.
Josep Ferrer's photo

Josep Ferrer

12 min

tutorial

Cómo formar a un LLM con PyTorch

Domine el proceso de entrenamiento de grandes modelos lingüísticos con PyTorch, desde la configuración inicial hasta la implementación final.
Zoumana Keita 's photo

Zoumana Keita

8 min

tutorial

Tutorial sobre cómo crear aplicaciones LLM con LangChain

Explore el potencial sin explotar de los grandes modelos lingüísticos con LangChain, un marco Python de código abierto para crear aplicaciones avanzadas de IA.
Moez Ali's photo

Moez Ali

12 min

Ver másVer más