Evaluar las solicitudes RAG con las RAGAs

Evaluar las solicitudes RAG con las RAGAs Descubre cómo obtener una calificación RAG exitosa

Un marco con métricas y datos generados por LLM para evaluar el rendimiento de tu pipeline de Generación Asistida por Recuperación

Ahora sabemos que construir una prueba de concepto para una aplicación de Generación Asistida por Recuperación (RAG) es fácil, pero hacerla lista para producción es muy difícil. Lograr que el rendimiento del pipeline de RAG sea satisfactorio es especialmente difícil debido a los diferentes componentes en un pipeline de RAG:

• Componente de Recuperación: recupera contexto adicional de una base de datos externa para que el LLM pueda responder la consulta.
• Componente de Generación: genera una respuesta basada en una entrada promovida con la información recuperada.

Cuando evalúas un pipeline de RAG, debes evaluar ambos componentes por separado y juntos para entender si y dónde el pipeline de RAG aún necesita mejora. Además, para entender si el rendimiento de tu aplicación de RAG está mejorando, debes evaluarlo de manera cuantitativa. Para esto, necesitarás dos ingredientes: una métrica de evaluación y un conjunto de datos de evaluación.

Actualmente, determinar las métricas de evaluación adecuadas y recopilar buenos datos de validación es un campo de investigación activo. En este tema en constante evolución, estamos viendo la aparición de varios enfoques para los marcos de evaluación de RAG, como la Triada de Métricas para RAG, ROUGE, ARES, BLUE y RAGAs [1]. Este artículo se centrará en cómo puedes evaluar un pipeline de RAG utilizando RAGAs [1].

¿Qué es RAGAs?

RAGAs (Recuperación-Augmentación de Generación Asistida) es un marco (GitHub, Docs) que te proporciona los ingredientes necesarios para ayudarte a evaluar tu pipeline de RAG a nivel de componente.

• Búsqueda de Haz el algoritmo más utilizado en modelos de secuencia
• ¿Ayuda el ensacado a prevenir el sobreajuste en los árboles de decisión?
• Este artículo de IA hace público HyperDreamer un avance en la creación de contenido 3D con texturizado avanzado, modelado de 360 grados y edición interactiva

Datos de Evaluación

Lo interesante de RAGAs es que comenzó como un marco de evaluación “sin referencia” [1]. Esto significa que, en lugar de tener que depender de etiquetas de verdad de referencia anotadas por humanos en el conjunto de datos de evaluación, RAGAs utiliza LLMs en el fondo para realizar las evaluaciones.

Para evaluar el pipeline de RAG, RAGAs espera la siguiente información:

• question: La consulta del usuario que es la entrada del pipeline de RAG. La entrada.
• answer: La respuesta generada por el pipeline de RAG. La salida.
• contexts: Los contextos recuperados de la fuente de conocimiento externa utilizados para responder la question.
• ground_truths: La respuesta de verdad de referencia para la question. Esta es la única información anotada por humanos necesaria. Esta información solo se requiere para la métrica context_recall (ver Métricas de Evaluación).

Utilizar LLMs para una evaluación sin referencia es un tema de investigación activo. Si bien utilizar la menor cantidad posible de datos anotados por humanos lo convierte en un método de evaluación más económico y rápido, aún se ha debatido sobre sus limitaciones, como el sesgo [3]. Sin embargo, algunos artículos ya han mostrado resultados prometedores [4]. Para obtener información detallada, consulta la sección “Related Work” del artículo sobre RAGAs [1].

Tenga en cuenta que el marco se ha ampliado para proporcionar métricas y paradigmas que requieren etiquetas de verdad absoluta (por ejemplo, context_recall y answer_correctness, consulte Métricas de Evaluación).

Además, el marco le proporciona herramientas para la generación automática de datos de prueba.

Métricas de Evaluación

Los RAGAs le brindan algunas métricas para evaluar un componente de canalización RAG por separado, así como la canalización en su conjunto.

En un nivel de componente, RAGAs le proporciona métricas para evaluar el componente de recuperación (context_relevancy y context_recall) y el componente generativo (faithfulness y answer_relevancy) por separado [2]:

• Precisión del contexto mide la relación señal-ruido del contexto recuperado. Esta métrica se calcula utilizando la pregunta y los contextos.
• Recuerdo del contexto mide si se recuperó toda la información relevante necesaria para responder la pregunta. Esta métrica se calcula en función de la ground_truth (esta es la única métrica en el marco que se basa en etiquetas de verdad absoluta anotadas por humanos) y los contextos.
• Fidelidad mide la precisión factual de la respuesta generada. El número de afirmaciones correctas de los contextos dados se divide por el número total de afirmaciones en la respuesta generada. Esta métrica utiliza la pregunta, los contextos y la respuesta.
• Relevancia de la respuesta mide qué tan relevante es la respuesta generada para la pregunta. Esta métrica se calcula utilizando la pregunta y la respuesta. Por ejemplo, la respuesta “Francia está en Europa occidental” a la pregunta “¿Dónde está Francia y cuál es su capital?” obtendría una baja relevancia de respuesta porque solo responde la mitad de la pregunta.

Todas las métricas están escaladas en el rango [0, 1], siendo valores más altos indicativos de un mejor rendimiento.

RAGAs también proporciona métricas para evaluar la canalización RAG de extremo a extremo, como similitud semántica de respuesta y corrección de respuesta. Este artículo se centra en las métricas a nivel de componente.

Evaluar una Aplicación RAG con RAGAs

Esta sección utiliza RAGAs para evaluar una canalización RAG mínima para mostrarle cómo usar RAGAs y para darle una intuición sobre sus métricas de evaluación.

Prerrequisitos

Asegúrese de haber instalado los paquetes de Python requeridos:

• langchain, openai y weaviate-client para la canalización RAG
• ragas para evaluar la canalización RAG

#!pip install langchain openai weaviate-client ragas

Además, defina sus variables de entorno relevantes en un archivo .env en su directorio raíz. Para obtener una clave de API de OpenAI, necesita una cuenta de OpenAI y luego “Crear nueva clave secreta” en claves de API.

OPENAI_API_KEY="<TU_CLAVE_DE_API_DE_OPENAI>"

Configuración de la aplicación RAG

Antes de poder evaluar tu aplicación RAG, debes configurarla. Utilizaremos una tubería RAG estándar. Mantendremos esta sección breve ya que utilizaremos la misma configuración descrita detalladamente en el siguiente artículo.

Recuperación Aumentada Generación (RAG): De la teoría a la implementación en LangChain

Desde la teoría del artículo académico original hasta su implementación en Python con OpenAI, Weaviate y LangChain

towardsdatascience.com

Primero, debes preparar los datos cargando y dividiendo los documentos.

import requestsfrom langchain.document_loaders import TextLoaderfrom langchain.text_splitter import CharacterTextSplitterurl = "https://raw.githubusercontent.com/langchain-ai/langchain/master/docs/docs/modules/state_of_the_union.txt"res = requests.get(url)with open("state_of_the_union.txt", "w") as f:    f.write(res.text)# Carga los datadataloader = TextLoader('./state_of_the_union.txt')documents = loader.load()# Divide los datatext_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)chunks = text_splitter.split_documents(documents)

A continuación, genera las incrustaciones vectoriales para cada fragmento utilizando el modelo de incrustación de OpenAI y almacénalas en la base de datos vectorial.

from langchain.embeddings import OpenAIEmbeddingsfrom langchain.vectorstores import Weaviateimport weaviatefrom weaviate.embedded import EmbeddedOptionsfrom dotenv import load_dotenv,find_dotenv# Carga la clave de la API de OpenAI desde el archivo .envload_dotenv(find_dotenv())# Configura la base de datos vectorialclient = weaviate.Client(  embedded_options = EmbeddedOptions())# Puebla la base de datos vectorialvectorstore = Weaviate.from_documents(    client = client,        documents = chunks,    embedding = OpenAIEmbeddings(),    by_text = False)# Define vectorstore como recuperador para habilitar la búsqueda semánticaretriever = vectorstore.as_retriever()

Por último, configura una plantilla de prompt y el modelo LLM de OpenAI y combínalos con el componente recuperador en una tubería RAG.

from langchain.chat_models import ChatOpenAIfrom langchain.prompts import ChatPromptTemplatefrom langchain.schema.runnable import RunnablePassthroughfrom langchain.schema.output_parser import StrOutputParser# Define LLMllm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)# Define la plantilla de prompttemplate = """Eres un asistente para tareas de pregunta-respuesta. Utiliza los siguientes fragmentos de contexto recuperados para responder la pregunta. Si no sabes la respuesta, simplemente di que no lo sabes. Utiliza un máximo de dos oraciones y mantén la respuesta concisa.Pregunta: {question} Contexto: {context} Respuesta:"""prompt = ChatPromptTemplate.from_template(template)# Configura la tubería RAGrag_chain = (    {"context": retriever,  "question": RunnablePassthrough()}     | prompt     | llm    | StrOutputParser() )

Preparación de los datos de evaluación

Como RAGAs tiene como objetivo ser un marco de evaluación sin referencia, los preparativos necesarios para el conjunto de datos de evaluación son mínimos. Deberás preparar pares pregunta y ground_truths a partir de los cuales podrás obtener la información restante a través de la inferencia de la siguiente manera:

from datasets import Datasetquestions = ["¿Qué dijo el presidente sobre el juez Breyer?",              "¿Qué dijo el presidente sobre el CEO de Intel?",             "¿Qué dijo el presidente sobre la violencia armada?",            ]ground_truths = [["El presidente dijo que el juez Breyer ha dedicado su vida a servir al país y le agradeció por su servicio."],                ["El presidente dijo que Pat Gelsinger está dispuesto a aumentar la inversión de Intel a 100 mil millones de dólares."],                ["El presidente pidió al Congreso que apruebe medidas comprobadas para reducir la violencia armada."]]answers = []contexts = []# Inferenciapara consulta in questions:  answers.append(rag_chain.invoke(query))  contexts.append([docs.page_content for docs in retriever.get_relevant_documents(query)])# Convertir a diccionariodata = {    "question": questions,    "answer": answers,    "contexts": contexts,    "ground_truths": ground_truths}# Convertir el diccionario en un conjuntodataset = Dataset.from_dict(data)

Si no estás interesado en la métrica context_recall, no necesitas proporcionar la información de ground_truths. En este caso, todo lo que necesitas preparar son las preguntas.

Evaluación de la aplicación RAG

Primero, importa todas las métricas que quieras usar de ragas.metrics. Luego, puedes usar la función evaluate() y simplemente pasar las métricas relevantes y el conjunto de datos preparado.

from ragas import evaluatefrom ragas.metrics import (    faithfulness,    answer_relevancy,    context_recall,    context_precision,)result = evaluate(    dataset = dataset,     metrics=[        context_precision,        context_recall,        faithfulness,        answer_relevancy,    ],)df = result.to_pandas()

A continuación, puedes ver las puntuaciones RAGAs resultantes para los ejemplos:

Podemos hacer las siguientes observaciones:

• context_relevancy (relación señal-ruido del contexto recuperado): Mientras que el LLM considera todo el contexto relevante para la última pregunta, también considera que la mayor parte del contexto recuperado para la segunda pregunta es irrelevante. Dependiendo de esta métrica, podrías experimentar con diferentes números de contextos recuperados para reducir el ruido.
• context_recall (si se recuperó toda la información relevante necesaria para responder la pregunta): Los LLM evalúan que los contextos recuperados contienen la información relevante necesaria para responder correctamente las preguntas.
• faithfulness (exactitud factual de la respuesta generada): Mientras que el LLM considera que las primeras y últimas preguntas son respondidas correctamente, la respuesta a la segunda pregunta, que afirma incorrectamente que el presidente no mencionó al CEO de Intel, se considera con una fidelidad del 0.5.
• answer_relevancy (qué tan relevante es la respuesta generada para la pregunta): Todas las respuestas generadas se consideran bastante relevantes para las preguntas.

Como se menciona en Evaluation Data, el uso de LLMs para la evaluación sin referencia es un campo de investigación activo. Me intriga ver cómo evolucionará este tema.

Resumen

Crear una aplicación de prueba de concepto de RAG es fácil, pero lograr que su rendimiento esté listo para producción es difícil. Al igual que en un proyecto de aprendizaje automático, debes evaluar el rendimiento del pipeline de RAG con un conjunto de datos de validación y una métrica de evaluación.

Sin embargo, dado que un pipeline de RAG consta de múltiples componentes que deben evaluarse por separado y en combinaciones, necesitarás un conjunto de métricas de evaluación. Además, generar un conjunto de datos de validación de alta calidad a partir de anotadores humanos es difícil, consume mucho tiempo y es costoso.

Este artículo ha presentado el framework de evaluación RAGAs [1]. El marco propone cuatro métricas de evaluación: context_relevancy, context_recall, faithfulness y answer_relevancy, que juntas conforman la puntuación RAGAs. Además, RAGAs aprovecha los LLMs en el fondo para la evaluación sin referencia y ahorrar costes.

Ahora que tienes las herramientas para evaluar el rendimiento de tu aplicación RAG, te recomiendo configurar un pipeline de experimentación y comenzar a ajustar el rendimiento con las siguientes estrategias de ajuste:

Una Guía sobre 12 Estrategias de Ajuste para Aplicaciones RAG Listas para Producción

Cómo mejorar el rendimiento de tu pipeline de Generación Augmentada de Recuperación (RAG) con estos “hiperparámetros” y…

towardsdatascience.com

Puedes encontrar el código para generar este conjunto de datos en este repositorio de GitHub.

¿Disfrutaste esta historia?

Suscríbete gratis para recibir notificaciones cuando publique una nueva historia.

Recibe un correo electrónico siempre que Leonie Monigatti publique.

Recibe un correo electrónico siempre que Leonie Monigatti publique. Al registrarte, crearás una cuenta de VoAGI si aún no la tienes…

VoAGI.com

Encuéntrame en LinkedIn, Twitter y Kaggle!

Renuncia

Soy un Defensor del Desarrollador en Weaviate, una base de datos vectorial de código abierto, en el momento de escribir esto.

Referencias

[1] Es, S., James, J., Espinosa-Anke, L., y Schockaert, S. (2023). RAGAs: Evaluación Automatizada de Generación Aumentada de Recuperación. arXiv preimpresión arXiv:2309.15217.

[2] Documentación de RAGAs (2023). Documentación (accedido el 11 de diciembre de 2023)

[3] Wang, P., Li, L., Chen, L., Zhu, D., Lin, B., Cao, Y., … & Sui, Z. (2023). Los modelos de lenguaje grandes no son evaluadores justos. arXiv preimpresión arXiv:2305.17926.

[4] Liu, Y., Iter, D., Xu, Y., Wang, S., Xu, R., y Zhu, C. (2023). G-eval: Evaluación Nlg utilizando GPT-4 con una mejor alineación humana, mayo de 2023. arXiv preimpresión arXiv: 2303.16634, 6.

Imágenes

Si no se indica lo contrario, todas las imágenes son creadas por el autor.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!