En este artículo, aprenderá cómo evaluar aplicaciones de modelos de lenguaje grandes utilizando marcos basados en RAGA y G-Eval en un flujo de trabajo práctico y práctico.
Los temas que cubriremos incluyen:
Cómo utilizar RAGA para medir la fidelidad y la relevancia de las respuestas en sistemas de recuperación aumentada. Cómo estructurar conjuntos de datos de evaluación e integrarlos en un proceso de prueba. Cómo aplicar G-Eval vía DeepEval para evaluar aspectos cualitativos como la coherencia.
Empecemos.
Una guía práctica para probar agentes con RAGA y G-Eval
Imagen del editor
Introducción
RAGA (Evaluación de generación aumentada de recuperación) es un marco de evaluación de código abierto que reemplaza las “verificaciones de vibraciones” subjetivas con un “juez” sistemático impulsado por LLM para cuantificar la calidad de las tuberías RAG. Evalúa una tríada de propiedades RAG deseables, incluida la precisión contextual y la relevancia de las respuestas. RAGA también ha evolucionado para admitir no solo arquitecturas RAG sino también aplicaciones basadas en agentes, donde metodologías como G-Eval desempeñan un papel en la definición de criterios de evaluación personalizados e interpretables.
Este artículo presenta una guía práctica para comprender cómo probar modelos de lenguaje grandes y aplicaciones basadas en agentes utilizando RAGA y marcos basados en G-Eval. Concretamente, aprovecharemos DeepEval, que integra múltiples métricas de evaluación en una zona de pruebas unificada.
Si no está familiarizado con marcos de evaluación como RAGA, considere revisar este artículo relacionado primero.
Guía paso a paso
Este ejemplo está diseñado para funcionar tanto en un IDE de Python independiente como en un cuaderno de Google Colab. Es posible que necesite instalar algunas bibliotecas a lo largo del camino para resolver posibles problemas de ModuleNotFoundError, que ocurren al intentar importar módulos que no están instalados en su entorno.
Comenzamos definiendo una función que toma una consulta del usuario como entrada e interactúa con una API LLM (como OpenAI) para generar una respuesta. Este es un agente simplificado que encapsula un flujo de trabajo básico de entrada-respuesta.
import openai def simple_agent(query): # NOTA: este es un bucle de agente ‘simulado’ # En un escenario real, usaría un mensaje del sistema para definir el uso de la herramienta.[{“role”: “user”, “content”: prompt}]) devolver respuesta.opciones[0].mensaje.contenido
importar abierto
definición agente_simple(consulta):
# NOTA: este es un bucle de agente ‘simulado’
# En un escenario real, usaría un mensaje del sistema para definir el uso de la herramienta.
inmediato = F“Eres un asistente útil. Responde la consulta del usuario: {query}”
# Ejemplo usando OpenAI (esto se puede cambiar por Gemini u otro proveedor)
respuesta = abierto.charlar.terminaciones.crear(
modelo=“gpt-3.5-turbo”,
mensajes=[{“role”: “user”, “content”: prompt}]
)
devolver respuesta.opciones[0].mensaje.contenido
En un entorno de producción más realista, el agente definido anteriormente incluiría capacidades adicionales como razonamiento, planificación y ejecución de herramientas. Sin embargo, dado que aquí el enfoque está en la evaluación, intencionalmente mantenemos la implementación simple.
A continuación, presentamos los RAGA. El siguiente código demuestra cómo evaluar un escenario de preguntas y respuestas utilizando la métrica de fidelidad, que mide qué tan bien se alinea la respuesta generada con el contexto proporcionado.
de ragas importar evaluar de ragas.metrics importar fidelidad # Definición de un conjunto de datos de prueba simple para un escenario de respuesta a preguntas data = { “pregunta”: [“What is the capital of Japan?”]”respuesta”: [“Tokyo is the capital.”]”contextos”: [[“Japan is a country in Asia. Its capital is Tokyo.”]]} # Ejecución del resultado de la evaluación de RAGA = evaluar (datos, métricas =[faithfulness])
de ragas importar evaluar
de ragas.métrica importar fidelidad
# Definir un conjunto de datos de prueba simple para un escenario de preguntas y respuestas
datos = {
“pregunta”: [“What is the capital of Japan?”],
“respuesta”: [“Tokyo is the capital.”],
“contextos”: [[“Japan is a country in Asia. Its capital is Tokyo.”]]
}
# Ejecución de la evaluación de RAGA
resultado = evaluar(datos, métrica=[faithfulness])
Tenga en cuenta que es posible que necesite una cuota de API suficiente (por ejemplo, OpenAI o Gemini) para ejecutar estos ejemplos, lo que normalmente requiere una cuenta paga.
A continuación se muestra un ejemplo más elaborado que incorpora una métrica adicional para la relevancia de las respuestas y utiliza un conjunto de datos estructurados.
casos_prueba = [
{
“question”: “How do I reset my password?”,
“answer”: “Go to settings and click ‘forgot password’. An email will be sent.”,
“contexts”: [“Users can reset passwords via the Settings > Security menu.”]”ground_truth”: “Vaya a Configuración, luego a Seguridad y seleccione Olvidé mi contraseña”. } ]
casos_de_prueba = [
{
“question”: “How do I reset my password?”,
“answer”: “Go to settings and click ‘forgot password’. An email will be sent.”,
“contexts”: [“Users can reset passwords via the Settings > Security menu.”],
“verdad_terreno”: “Vaya a Configuración, luego a Seguridad y seleccione Olvidé mi contraseña”.
}
]
Asegúrese de que su clave API esté configurada antes de continuar. Primero, demostramos la evaluación sin incluir la lógica en un agente:
importar sistema operativo desde ragas importar evaluar desde ragas.metrics importar fidelidad, respuesta_relevancia de conjuntos de datos importar conjunto de datos # IMPORTANTE: Reemplace “YOUR_API_KEY” con su clave API real os.environ[“OPENAI_API_KEY”] = “YOUR_API_KEY” # Convertir lista a conjunto de datos de caras abrazadas (requerido por RAGA) conjunto de datos = Dataset.from_list(test_cases) # Ejecutar evaluación ragas_results = evaluar(conjunto de datos, métricas=[faithfulness, answer_relevancy]) print(f”Puntuación de fidelidad de RAGAs: {ragas_results[‘faithfulness’]}”)
importar sistema operativo
de ragas importar evaluar
de ragas.métrica importar fidelidad, respuesta_relevancia
de conjuntos de datos importar Conjunto de datos
# IMPORTANTE: Reemplace “YOUR_API_KEY” con su clave API real
sistema operativo.reinar[“OPENAI_API_KEY”] = “TU_API_KEY”
# Convertir la lista al conjunto de datos de caras abrazadas (requerido por los RAGA)
conjunto de datos = Conjunto de datos.de_lista(casos_de_prueba)
# Ejecutar evaluación
ragas_resultados = evaluar(conjunto de datos, métrica=[faithfulness, answer_relevancy])
imprimir(F“Puntuación de fidelidad de RAGA: {ragas_results[‘faithfulness’]}”)
Para simular un flujo de trabajo basado en agentes, podemos encapsular la lógica de evaluación en una función reutilizable:
importar sistema operativo de ragas importar evaluar de ragas.metrics importar fidelidad, respuesta_relevancia de conjuntos de datos importar conjunto de datos def evaluar_ragas_agent(test_cases, openai_api_key=”YOUR_API_KEY”): “””Simula un agente de IA simple que realiza una evaluación de RAGA.””” os.environ[“OPENAI_API_KEY”] = openai_api_key # Convertir casos de prueba en un objeto de conjunto de datos dataset = Dataset.from_list(test_cases) # Ejecutar evaluación ragas_results = evaluar(conjunto de datos, métricas=[faithfulness, answer_relevancy]) devolver ragas_results
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importar sistema operativo
de ragas importar evaluar
de ragas.métrica importar fidelidad, respuesta_relevancia
de conjuntos de datos importar Conjunto de datos
definición evaluar_ragas_agent(casos_de_prueba, openai_api_key=“TU_API_KEY”):
“”“Simula un agente de IA simple que realiza la evaluación de RAGA”.“”
sistema operativo.reinar[“OPENAI_API_KEY”] = openai_api_llave
# Convertir casos de prueba en un objeto de conjunto de datos
conjunto de datos = Conjunto de datos.de_lista(casos_de_prueba)
# Ejecutar evaluación
ragas_resultados = evaluar(conjunto de datos, métrica=[faithfulness, answer_relevancy])
devolver ragas_resultados
El objeto Hugging Face Dataset está diseñado para representar de manera eficiente datos estructurados para la evaluación e inferencia de modelos de lenguaje grandes.
El siguiente código demuestra cómo llamar a la función de evaluación:
my_openai_key = “YOUR_API_KEY” # Reemplazar con su clave API real si ‘test_cases’ en globals(): evaluacion_output = evalua_ragas_agent(test_cases, openai_api_key=my_openai_key) print(“Resultados de la evaluación RAGAs:”) print(evaluación_salida) else: print(“Defina primero la variable ‘test_cases’. Ejemplo:”) print(“test_cases = [{ ‘question’: ‘…’, ‘answer’: ‘…’, ‘contexts’: […]’ground_truth’: ‘…’ }]”)
mi_openai_key = “TU_API_KEY” # Reemplace con su clave API real
si ‘casos_de prueba’ en globales():
salida_evaluación = evaluar_ragas_agent(casos_de_prueba, openai_api_key=mi_openai_key)
imprimir(“Resultados de la evaluación RAGA:”)
imprimir(salida_evaluación)
demás:
imprimir(“Primero defina la variable ‘test_cases’. Ejemplo:”)
imprimir(“casos_prueba = [{ ‘question’: ‘…’, ‘answer’: ‘…’, ‘contexts’: […]’ground_truth’: ‘…’ }]”)
Ahora presentamos DeepEval, que actúa como una capa de evaluación cualitativa utilizando un enfoque de razonamiento y puntuación. Esto es particularmente útil para evaluar atributos como coherencia, claridad y profesionalismo.
from deepeval.metrics import GEval from deepeval.test_case import LLMTestCase, LLMTestCaseParams # PASO 1: Definir una métrica de evaluación personalizada coherence_metric = GEval( name=”Coherence”, criterios=”Determine si la respuesta es fácil de seguir y está estructurada lógicamente.”, evaluación_params=[LLMTestCaseParams.INPUT, LLMTestCaseParams.ACTUAL_OUTPUT]umbral=0.7 # Umbral de aprobación/fallo ) # PASO 2: Crear un caso de prueba case = LLMTestCase( input=test_cases[0][“question”]salida_actual=casos_de_prueba[0][“answer”]) # PASO 3: Ejecutar la evaluación coherence_metric.measure(case) print(f”G-Eval Score: {coherence_metric.score}”) print(f”Razonamiento: {coherence_metric.reason}”)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
de profundo.métrica importar valor GEval
de profundo.caso_prueba importar Caso de prueba LLMT, LLMTestCaseParams
# PASO 1: Definir una métrica de evaluación personalizada
coherencia_métrica = valor GEval(
nombre=“Coherencia”,
criterios=“Determine si la respuesta es fácil de seguir y está lógicamente estructurada”.,
parámetros_evaluación=[LLMTestCaseParams.INPUT, LLMTestCaseParams.ACTUAL_OUTPUT],
límite=0,7 # Umbral de pasa/falla
)
# PASO 2: Crear un caso de prueba
caso = Caso de prueba LLMT(
aporte=casos_de_prueba[0][“question”],
salida_actual=casos_de_prueba[0][“answer”]
)
# PASO 3: Ejecutar evaluación
coherencia_métrica.medida(caso)
imprimir(F“Puntuación de evaluación G: {coherence_metric.score}”)
imprimir(F“Razonamiento: {coherencia_metric.reason}”)
Un resumen rápido de los pasos clave:
Defina una métrica personalizada utilizando criterios de lenguaje natural y un umbral entre 0 y 1. Cree un LLMTestCase utilizando sus datos de prueba. Ejecutar la evaluación utilizando el método de medida.
Resumen
Este artículo demostró cómo evaluar modelos de lenguaje grandes y aplicaciones de recuperación aumentada utilizando marcos basados en RAGA y G-Eval. Al combinar métricas estructuradas (fidelidad y relevancia) con una evaluación cualitativa (coherencia), puede crear un proceso de evaluación más completo y confiable para los sistemas de IA modernos.