Evaluación de aplicaciones RAG con RAGA | de Leonie Monigatti | diciembre de 2023

RAGA (Retrieval-Aaumentado GRAMOgeneración Comosesión) es un marco (GitHub, Documentos) que le proporciona los ingredientes necesarios para ayudarle a evaluar su canalización RAG a nivel de componentes.

Datos de evaluación

Lo interesante de los RAGA es que comenzaron como un marco para la evaluación “sin referencias”. [1]. Eso significa que, en lugar de tener que depender de etiquetas de verdad reales anotadas por humanos en el conjunto de datos de evaluación, RAGA aprovecha los LLM para realizar las evaluaciones.

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

• question: la consulta del usuario que es la entrada de la canalización RAG. La entrada.
• answer: La respuesta generada a partir del proceso RAG. La salida.
• contexts: Los contextos recuperados de la fuente de conocimiento externo utilizados para responder a la question.
• ground_truths: La respuesta real a la pregunta question. Esta es la única información anotada por humanos. Esta información solo es necesaria para la métrica. context_recall (ver Métricas de evaluación).

Aprovechar los LLM para una evaluación sin referencias es un tema de investigación activo. Si bien el uso de la menor cantidad posible de datos anotados por humanos lo convierte en un método de evaluación más barato y rápido, todavía hay cierta discusión sobre sus deficiencias, como el sesgo. [3]. Sin embargo, algunos artículos ya han mostrado resultados prometedores. [4]. Para obtener información detallada, consulte la sección “Trabajos relacionados” de los RAGA. [1] papel.

Tenga en cuenta que el marco se ha ampliado para proporcionar métricas y paradigmas que requieren etiquetas de verdad sobre el terreno (p. ej., context_recall y answer_correctnessver Métricas de evaluación).

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

Métricas de evaluación

Los RAGA le proporcionan algunos métrica para evaluar una tubería RAG tanto por componentes como de extremo a extremo.

En un nivel de componenteRAGAs 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 el question y el contexts.
• Recuerdo de contexto medidas si se recuperó toda la información relevante requerida para responder la pregunta. Esta métrica se calcula en base a la ground_truth (esta es la única métrica en el marco que se basa en etiquetas de verdad terrestre anotadas por humanos) y la contexts.
• Fidelidad Mide la precisión fáctica 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 el question, contextsy el answer.
• Relevancia de la respuesta Mide qué tan relevante es la respuesta generada para la pregunta. Esta métrica se calcula utilizando el question y el answer. Por ejemplo, la respuesta “Francia está en Europa occidental..” a la pregunta “¿Dónde está Francia y cuál es su capital?” lograría una relevancia de respuesta baja porque solo responde la mitad de la pregunta.

Todas las métricas están escaladas al rango. [0, 1]donde los valores más altos indican un mejor rendimiento.

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

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

Requisitos previos

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

• langchain, openaiy weaviate-client para el oleoducto RAG
• ragas para evaluar el oleoducto 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 API de OpenAI, necesita una cuenta OpenAI y luego “Crear nueva clave secreta” en Claves API.

OPENAI_API_KEY="<YOUR_OPENAI_API_KEY>"

Configurar la aplicación RAG

Antes de poder evaluar su aplicación RAG, debe configurarla. Usaremos una tubería RAG de vainilla. Mantendremos esta sección breve ya que usaremos la misma configuración que se describe en detalle en el siguiente artículo.

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

import requests
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
url = "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)
# Load the data
loader = TextLoader('./state_of_the_union.txt')
documents = loader.load()
# Chunk the data
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = text_splitter.split_documents(documents)

A continuación, genere las incrustaciones de vectores para cada fragmento con el modelo de incrustación de OpenAI y guárdelas en la base de datos de vectores.

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Weaviate
import weaviate
from weaviate.embedded import EmbeddedOptions
from dotenv import load_dotenv,find_dotenv
# Load OpenAI API key from .env file
load_dotenv(find_dotenv())
# Setup vector database
client = weaviate.Client(
embedded_options = EmbeddedOptions()
)
# Populate vector database
vectorstore = Weaviate.from_documents(
client = client,    
documents = chunks,
embedding = OpenAIEmbeddings(),
by_text = False
)
# Define vectorstore as retriever to enable semantic search
retriever = vectorstore.as_retriever()

Finalmente, configure una plantilla de solicitud y OpenAI LLM y combínelos con el componente de recuperación en una canalización RAG.

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnablePassthrough
from langchain.schema.output_parser import StrOutputParser
# Define LLM
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)
# Define prompt template
template = """You are an assistant for question-answering tasks. 
Use the following pieces of retrieved context to answer the question. 
If you don't know the answer, just say that you don't know. 
Use two sentences maximum and keep the answer concise.
Question: {question} 
Context: {context} 
Answer:
"""
prompt = ChatPromptTemplate.from_template(template)
# Setup RAG pipeline
rag_chain = (
{"context": retriever,  "question": RunnablePassthrough()} 
| prompt 
| llm
| StrOutputParser() 
)

Preparación de los datos de evaluación

Dado que RAGA pretende ser un marco de evaluación sin referencias, los preparativos necesarios del conjunto de datos de evaluación son mínimos. Necesitarás prepararte question y ground_truths pares a partir de los cuales se puede preparar la información restante mediante inferencia de la siguiente manera:

from datasets import Dataset
questions = ["What did the president say about Justice Breyer?", 
"What did the president say about Intel's CEO?",
"What did the president say about gun violence?",
]
ground_truths = [["The president said that Justice Breyer has dedicated his life to serve the country and thanked him for his service."],
["The president said that Pat Gelsinger is ready to increase Intel's investment to $100 billion."],
["The president asked Congress to pass proven measures to reduce gun violence."]]
answers = []
contexts = []
# Inference
for query in questions:
answers.append(rag_chain.invoke(query))
contexts.append([docs.page_content for docs in retriever.get_relevant_documents(query)])
# To dict
data = {
"question": questions,
"answer": answers,
"contexts": contexts,
"ground_truths": ground_truths
}
# Convert dict to dataset
dataset = Dataset.from_dict(data)

Si no estás interesado en el context_recall métrica, no es necesario proporcionar la ground_truths información. En este caso, todo lo que necesitas preparar es el questions.

Evaluación de la aplicación RAG

Primero, importe todas las métricas que desee utilizar ragas.metrics. Entonces, puedes usar el evaluate() funcionar y simplemente pasar las métricas relevantes y el conjunto de datos preparado.

from ragas import evaluate
from 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, puede ver las puntuaciones RAGA resultantes de los ejemplos: