Los LLM como GPT-3, GPT-4 y su contraparte de código abierto a menudo luchan con la recuperación de información actualizada y a veces pueden generar alucinaciones o información incorrecta.
La generación de recuperación aumentada (RAG) es una técnica que combina el poder de los LLM con la recuperación de conocimiento externo. RAG nos permite a tierra las respuestas de LLM en información de hecho, actualizada, mejorando significativamente la precisión y confiabilidad del contenido generado por IA.
En esta publicación de blog, exploraremos cómo construir agentes de LLM para trapo desde cero, sumergirse profundamente en la arquitectura, los detalles de implementación y las técnicas avanzadas. Cubriremos todo, desde los conceptos básicos del trapo hasta la creación de agentes sofisticados capaces de razonamiento complejo y ejecución de tareas.
Antes de sumergirnos en la construcción de nuestro agente de LLM, comprendamos qué es el trapo y por qué es importante.
El trapo, o la generación de recuperación y una generación de recuperación, es un enfoque híbrido que combina la recuperación de información con la generación de texto. En un sistema de trapo:
- Se utiliza una consulta para recuperar documentos relevantes de una base de conocimiento.
- Estos documentos se alimentan en un modelo de idioma junto con la consulta original.
- El modelo genera una respuesta basada tanto en la consulta como en la información recuperada.
TRAPO
Este enfoque tiene varias ventajas:
- Precisión mejorada: Al fundamentar las respuestas en información recuperada, el trapo reduce las alucinaciones y mejora la precisión objetiva.
- Información actualizada: La base de conocimiento se puede actualizar regularmente, lo que permite que el sistema acceda a la información actual.
- Transparencia: El sistema puede proporcionar fuentes para su información, aumentar la confianza y permitir la verificación de hechos.
Comprender los agentes de LLM
Agentes alimentados con LLM
Cuando enfrenta un problema sin una respuesta simple, a menudo debe seguir varios pasos, pensar con cuidado y recordar lo que ya ha probado. Los agentes de LLM están diseñados para este tipo de situaciones en aplicaciones de modelos de idiomas. Combinan análisis de datos exhaustivos, planificación estratégica, recuperación de datos y la capacidad de aprender de acciones pasadas para resolver problemas complejos.
¿Qué son los agentes de LLM?
Los agentes de LLM son sistemas AI avanzados diseñados para crear un texto complejo que requiere un razonamiento secuencial. Pueden pensar con anticipación, recordar conversaciones pasadas y usar diferentes herramientas para ajustar sus respuestas en función de la situación y el estilo necesarios.
Considere una pregunta en el campo legal como: «¿Cuáles son los resultados legales potenciales de un tipo específico de violación de contrato en California?» Una LLM básica con un sistema de generación aumentada de recuperación (RAG) puede obtener la información necesaria de las bases de datos legales.
Para un escenario más detallado: «A la luz de las nuevas leyes de privacidad de datos, ¿cuáles son los desafíos legales comunes que enfrentan las empresas y cómo han abordado los tribunales estos problemas?» Esta pregunta profundiza más que solo buscar hechos. Se trata de comprender las nuevas reglas, su impacto en diferentes empresas y las respuestas judiciales. Un agente de LLM dividiría esta tarea en subtareas, como recuperar las últimas leyes, analizar casos históricos, resumir documentos legales y pronosticar tendencias basadas en patrones.
Componentes de los agentes LLM
Los agentes de LLM generalmente consisten en cuatro componentes:
- Agente/cerebro: El modelo de lenguaje central que procesa y comprende el lenguaje.
- Planificación: La capacidad de razonar, desglosar tareas y desarrollar planes específicos.
- Memoria: Mantiene registros de interacciones pasadas y aprende de ellas.
- Uso de la herramienta: Integra varios recursos para realizar tareas.
Agente/cerebro
En el núcleo de un agente de LLM hay un modelo de idioma que procesa y comprende el lenguaje basado en grandes cantidades de datos en los que ha sido entrenado. Comienza dándole un aviso específico, guiando al agente sobre cómo responder, qué herramientas usar y los objetivos para apuntar. Puede personalizar al agente con una persona adecuada para tareas o interacciones particulares, mejorando su rendimiento.
Memoria
El componente de memoria ayuda a los agentes de LLM a manejar tareas complejas manteniendo un registro de acciones pasadas. Hay dos tipos principales de memoria:
- Memoria a corto plazo: Actúa como un bloc de notas, realizando un seguimiento de las discusiones en curso.
- Memoria a largo plazo: Funciones como un diario, almacenar información de interacciones pasadas para aprender patrones y tomar mejores decisiones.
Al combinar este tipo de memoria, el agente puede ofrecer respuestas más personalizadas y recordar las preferencias del usuario con el tiempo, creando una interacción más conectada y relevante.
Planificación
La planificación permite a los agentes de LLM razonar, descomponer las tareas en piezas manejables y adaptar los planes a medida que evolucionan las tareas. La planificación implica dos etapas principales:
- Formulación de plan: Desglosar una tarea en subasinas más pequeñas.
- Reflexión del plan: Revisar y evaluar la efectividad del plan, incorporando comentarios para refinar estrategias.
Métodos como la cadena de pensamiento (COT) y el árbol de pensamiento (TOT) ayudan en este proceso de descomposición, lo que permite a los agentes explorar diferentes caminos para resolver un problema.
Para profundizar en el mundo de los agentes de la IA, incluidas sus capacidades y potencial actuales, considere leer «Auto-GPT y GPT-Engineer: una guía en profundidad para los principales agentes de IA principales de hoy»
Configuración del medio ambiente
Para construir nuestro agente de trapo, necesitaremos configurar nuestro entorno de desarrollo. Usaremos Python y varias bibliotecas clave:
- Langchain: Para orquestar nuestros LLM y componentes de recuperación
- Croma: Como nuestra tienda vectorial para incrustaciones de documentos
- Modelos GPT de Openai: Como nuestro Base LLM (puede sustituir esto con un modelo de código abierto si se prefiere)
- Fastapi: Para crear una API simple para interactuar con nuestro agente
Comencemos por configurar nuestro entorno:
# Create a new virtual environment python -m venv rag_agent_env source rag_agent_env/bin/activate # On Windows, use `rag_agent_env\Scripts\activate` # Install required packages pip install langchain chromadb openai fastapi uvicorn
Ahora, creemos un nuevo archivo de Python llamado rag_agent.py e importe las bibliotecas necesarias:
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
import os
# Set your OpenAI API key
os.environ("OPENAI_API_KEY") = "your-api-key-here"
Construyendo un sistema de trapo simple
Ahora que tenemos nuestro entorno configurado, construamos un sistema de trapo básico. Comenzaremos creando una base de conocimiento a partir de un conjunto de documentos, luego usaremos esto para responder consultas.
Paso 1: Prepare los documentos
Primero, necesitamos cargar y preparar nuestros documentos. Para este ejemplo, supongamos que tenemos un archivo de texto llamado Knowledge_Base.txt con alguna información sobre AI y Machine Learning.
# Load the document
loader = TextLoader("knowledge_base.txt")
documents = loader.load()
# Split the documents into chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)
# Create embeddings
embeddings = OpenAIEmbeddings()
# Create a vector store
vectorstore = Chroma.from_documents(texts, embeddings)
Paso 2: crear una cadena de control de calidad basada en recuperación
Ahora que tenemos nuestra tienda vectorial, podemos crear una cadena de control de calidad basada en recuperación:
# Create a retrieval-based QA chain qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever())
Paso 3: consulta el sistema
Ahora podemos consultar nuestro sistema de trapo:
query = "What are the main applications of machine learning?" result = qa.run(query) print(result)
Paso 4: Creación de un agente de LLM
Si bien nuestro sistema de trapo simple es útil, es bastante limitado. Vamos a mejorarlo creando un agente LLM que pueda realizar tareas más complejas y razonar sobre la información que recupera.
Un agente de LLM es un sistema de IA que puede usar herramientas y tomar decisiones sobre qué acciones tomar. Crearemos un agente que no solo puede responder preguntas, sino que también realizaremos búsquedas web y cálculos básicos.
Primero, definamos algunas herramientas para nuestro agente:
from langchain.agents import Tool
from langchain.tools import DuckDuckGoSearchRun
from langchain.tools import BaseTool
from langchain.agents import initialize_agent
from langchain.agents import AgentType
# Define a calculator tool
class CalculatorTool(BaseTool):
name = "Calculator"
description = "Useful for when you need to answer questions about math"
def _run(self, query: str)
try:
return str(eval(query))
except:
return "I couldn't calculate that. Please make sure your input is a valid mathematical expression."
# Create tool instances
search = DuckDuckGoSearchRun()
calculator = CalculatorTool()
# Define the tools
tools = (Tool(name="Search",func=search.run,description="Useful for when you need to answer questions about current events"),
Tool(name="RAG-QA",func=qa.run,description="Useful for when you need to answer questions about AI and machine learning"),
Tool(name="Calculator",func=calculator._run,description="Useful for when you need to perform mathematical calculations")
)
# Initialize the agent
agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
Ahora tenemos un agente que puede usar nuestro sistema RAG, realizar búsquedas web y hacer cálculos. Vamos a probarlo:
result = agent.run("What's the difference between supervised and unsupervised learning? Also, what's 15% of 80?")
print(result)
Este agente demuestra una ventaja clave de los agentes de LLM: pueden combinar múltiples herramientas y pasos de razonamiento para responder consultas complejas.
Mejorar el agente con técnicas avanzadas de trapo
Si bien nuestro sistema RAG actual funciona bien, hay varias técnicas avanzadas que podemos usar para mejorar su rendimiento:
a) Búsqueda semántica con una densa recuperación de pasos (DPR)
En lugar de usar una recuperación simple basada en la incrustación, podemos implementar DPR para una búsqueda semántica más precisa:
from transformers import DPRQuestionEncoder, DPRContextEncoder
question_encoder = DPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
context_encoder = DPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")
# Function to encode passages
def encode_passages(passages):
return context_encoder(passages, max_length=512, return_tensors="pt").pooler_output
# Function to encode query
def encode_query(query):
return question_encoder(query, max_length=512, return_tensors="pt").pooler_output
b) expansión de consulta
Podemos usar la expansión de la consulta para mejorar el rendimiento de la recuperación:
from transformers import T5ForConditionalGeneration, T5Tokenizer
model = T5ForConditionalGeneration.from_pretrained("t5-small")
tokenizer = T5Tokenizer.from_pretrained("t5-small")
def expand_query(query):
input_text = f"expand query: {query}"
input_ids = tokenizer.encode(input_text, return_tensors="pt")
outputs = model.generate(input_ids, max_length=50, num_return_sequences=3)
expanded_queries = (tokenizer.decode(output, skip_special_tokens=True) for output in outputs)
return expanded_queries
c) Refinamiento iterativo
Podemos implementar un proceso de refinamiento iterativo donde el agente pueda hacer preguntas de seguimiento para aclarar o ampliar su recuperación inicial:
def iterative_retrieval(initial_query, max_iterations=3):
query = initial_query
for _ in range(max_iterations):
result = qa.run(query)
clarification = agent.run(f"Based on this result: '{result}', what follow-up question should I ask to get more specific information?")
if clarification.lower().strip() == "none":
break
query = clarification
return result
# Use this in your agent's process
Implementación de un sistema de múltiples agentes
Para manejar tareas más complejas, podemos implementar un sistema de múltiples agentes donde diferentes agentes se especializan en diferentes áreas. Aquí hay un ejemplo simple:
class SpecialistAgent:
def __init__(self, name, tools):
self.name = name
self.agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
def run(self, query):
return self.agent.run(query)
# Create specialist agents
research_agent = SpecialistAgent("Research", (Tool(name="RAG-QA", func=qa.run, description="For AI and ML questions")))
math_agent = SpecialistAgent("Math", (Tool(name="Calculator", func=calculator._run, description="For calculations")))
general_agent = SpecialistAgent("General", (Tool(name="Search", func=search.run, description="For general queries")))
class Coordinator:
def __init__(self, agents):
self.agents = agents
def run(self, query):
# Determine which agent to use
if "calculate" in query.lower() or any(op in query for op in ('+', '-', '*', '/')):
return self.agents('Math').run(query)
elif any(term in query.lower() for term in ('ai', 'machine learning', 'deep learning')):
return self.agents('Research').run(query)
else:
return self.agents('General').run(query)
coordinator = Coordinator({'Research': research_agent, 'Math': math_agent, 'General': general_agent})
# Test the multi-agent system
result = coordinator.run("What's the difference between CNN and RNN? Also, calculate 25% of 120.")
print(result)
Este sistema de múltiples agentes permite especialización y puede manejar una gama más amplia de consultas de manera más efectiva.
Evaluar y optimizar los agentes de Rag
Para garantizar que nuestro agente de RAG esté funcionando bien, necesitamos implementar métricas de evaluación y técnicas de optimización:
a) Evaluación de relevancia
Podemos usar métricas como Bleu, Rouge o Bertscore para evaluar la relevancia de los documentos recuperados:
from bert_score import score def evaluate_relevance(query, retrieved_doc, generated_answer): P, R, F1 = score((generated_answer), (retrieved_doc), lang="en") return F1.mean().item()
b) Responder Evaluación de calidad
Podemos usar evaluación humana o métricas automatizadas para evaluar la calidad de la respuesta:
from nltk.translate.bleu_score import sentence_bleu def evaluate_answer_quality(reference_answer, generated_answer): return sentence_bleu((reference_answer.split()), generated_answer.split()) # Use this to evaluate your agent's responses
Direcciones y desafíos futuros
Al mirar el futuro de los agentes de Rag, surgen varias direcciones y desafíos emocionantes:
a) Trapo multimodal: Extender el trapo para incorporar datos de imagen, audio y video.
b) Trapo federado: Implementación del trapo en bases de conocimiento distribuidas y preservantes de la privacidad.
do) Aprendizaje continuo: Desarrollo de métodos para que los agentes de RAG actualicen sus bases de conocimiento y modelos a lo largo del tiempo.
d) Consideraciones éticas: Abordar el sesgo, la justicia y la transparencia en los sistemas de RAG.
mi) Escalabilidad: Optimización del trapo para aplicaciones a gran escala en tiempo real.
Conclusión
Construir agentes LLM para trapo desde cero es un proceso complejo pero gratificante. Hemos cubierto los conceptos básicos de RAG, implementamos un sistema simple, creamos un agente de LLM, lo mejoramos con técnicas avanzadas, exploró sistemas de agentes múltiples y discutimos estrategias de evaluación y optimización.