Intelligenza generale artificiale
Creazione di agenti LLM per RAG da zero e oltre: una guida completa
Gli LLM come GPT-3, GPT-4 e la loro controparte open source spesso hanno difficoltà con il recupero di informazioni aggiornate e talvolta possono generare allucinazioni o informazioni errate.
Generazione aumentata di recupero (RAG) è una tecnica che combina la potenza dei LLM con il recupero della conoscenza esterna. RAG ci consente di fondare le risposte LLM su informazioni reali e aggiornate, migliorando significativamente l'accuratezza e l'affidabilità dei contenuti generati dall'intelligenza artificiale.
In questo articolo del blog, esploreremo come creare agenti LLM per RAG da zero, approfondendo l'architettura, i dettagli di implementazione e le tecniche avanzate. Tratteremo tutto, dalle basi di RAG alla creazione di agenti sofisticati in grado di eseguire ragionamenti complessi ed eseguire attività.
Prima di addentrarci nella creazione del nostro agente LLM, cerchiamo di capire cos'è RAG e perché è importante.
RAG, o Retrieval-Augmented Generation, è un approccio ibrido che combina il recupero delle informazioni con la generazione di testo. In un sistema RAG:
- Una query viene utilizzata per recuperare documenti rilevanti da una knowledge base.
- Questi documenti vengono quindi inseriti in un modello linguistico insieme alla query originale.
- Il modello genera una risposta basata sia sulla query che sulle informazioni recuperate.
RAG
Questo approccio ha diversi vantaggi:
- Precisione migliorata: Radicando le risposte nelle informazioni recuperate, RAG riduce le allucinazioni e migliora l'accuratezza dei fatti.
- Informazioni aggiornate: La base di conoscenza può essere aggiornata regolarmente, consentendo al sistema di accedere alle informazioni attuali.
- Trasparenza: Il sistema può fornire fonti per le sue informazioni, aumentando la fiducia e consentendo il controllo dei fatti.
Comprendere gli agenti LLM
Quando affronti un problema senza una risposta semplice, spesso devi seguire diversi passaggi, riflettere attentamente e ricordare ciò che hai già provato. Gli agenti LLM sono progettati esattamente per questo tipo di situazioni nelle applicazioni del modello linguistico. Combinano analisi approfondita dei dati, pianificazione strategica, recupero dei dati e capacità di apprendere dalle azioni passate per risolvere problemi complessi.
Cosa sono gli agenti LLM?
Gli agenti LLM sono sistemi di intelligenza artificiale avanzati progettati per la creazione di testi complessi che richiedono un ragionamento sequenziale. Possono pensare al futuro, ricordare le conversazioni passate e utilizzare diversi strumenti per adattare le loro risposte in base alla situazione e allo stile necessario.
Consideriamo una domanda in campo legale come: “Quali sono i potenziali risultati legali di un tipo specifico di violazione contrattuale in California?” Un LLM di base con un sistema RAG (retrieval augmented generation) può recuperare le informazioni necessarie dai database legali.
Per uno scenario più dettagliato: "Alla luce delle nuove leggi sulla privacy dei dati, quali sono le sfide legali più comuni che le aziende devono affrontare e come le hanno affrontate i tribunali?". Questa domanda va oltre la semplice ricerca di fatti. Riguarda la comprensione delle nuove norme, il loro impatto sulle diverse aziende e le risposte dei tribunali. Un agente LLM suddividerebbe questo compito in sotto-attività, come il recupero delle leggi più recenti, l'analisi dei casi storici, la sintesi dei documenti legali e la previsione delle tendenze in base a modelli.
Componenti degli agenti LLM
Gli agenti LLM sono generalmente costituiti da quattro componenti:
- Agente/Cervello: il modello linguistico fondamentale che elabora e comprende il linguaggio.
- Pianificazione: La capacità di ragionare, suddividere i compiti e sviluppare piani specifici.
- Memorie: conserva le registrazioni delle interazioni passate e impara da esse.
- Uso dello strumento: integra varie risorse per eseguire attività.
Agente/Cervello
Al centro di un agente LLM c'è un modello linguistico che elabora e comprende il linguaggio sulla base di grandi quantità di dati su cui è stato addestrato. Inizi dandogli un suggerimento specifico, guidando l'agente su come rispondere, quali strumenti utilizzare e gli obiettivi a cui mirare. Puoi personalizzare l'agente con un personaggio adatto a particolari attività o interazioni, migliorandone le prestazioni.
Memorie
Il componente di memoria aiuta gli agenti LLM a gestire attività complesse mantenendo un registro delle azioni passate. Esistono due tipi principali di memoria:
- Memoria a breve termine: funziona come un blocco note e tiene traccia delle discussioni in corso.
- Memoria a lungo termine: Funziona come un diario, memorizzando informazioni dalle interazioni passate per apprendere modelli e prendere decisioni migliori.
Combinando questi tipi di memoria, l'agente può offrire risposte più personalizzate e ricordare le preferenze dell'utente nel tempo, creando un'interazione più connessa e pertinente.
Pianificazione
La pianificazione consente agli agenti LLM di ragionare, scomporre le attività in parti gestibili e adattare i piani man mano che le attività evolvono. La pianificazione prevede due fasi principali:
- Formulazione del piano: suddividere un'attività in sottoattività più piccole.
- Piano di riflessione: Revisione e valutazione dell'efficacia del piano, incorporando feedback per perfezionare le strategie.
Metodi come la Catena del Pensiero (CoT) e l'Albero del Pensiero (ToT) aiutano in questo processo di scomposizione, consentendo agli agenti di esplorare diversi percorsi per risolvere un problema.
Per approfondire il mondo degli agenti IA, comprese le loro attuali capacità e potenzialità, prendi in considerazione la lettura "Auto-GPT e GPT-Engineer: una guida approfondita ai principali agenti IA di oggi"
Preparare l'ambiente
Per creare il nostro agente RAG, dovremo configurare il nostro ambiente di sviluppo. Utilizzeremo Python e diverse librerie chiave:
- LangChain: Per orchestrare i nostri componenti LLM e di recupero
- Chroma: come il nostro archivio vettoriale per gli incorporamenti di documenti
- Modelli GPT di OpenAI: Come il nostro LLM di base (puoi sostituirlo con un modello open source, se preferisci)
- API veloce: Per creare una semplice API per interagire con il nostro agente
Iniziamo configurando il nostro ambiente:
# 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
Ora creiamo un nuovo file Python chiamato rag_agent.py e importiamo le librerie necessarie:
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"
Costruire un semplice sistema RAG
Ora che abbiamo configurato il nostro ambiente, costruiamo un sistema RAG di base. Inizieremo creando una knowledge base da un insieme di documenti, che utilizzeremo per rispondere alle query.
Passaggio 1: preparare i documenti
Per prima cosa, dobbiamo caricare e preparare i nostri documenti. Per questo esempio, supponiamo di avere un file di testo chiamato knowledge_base.txt con alcune informazioni sull'intelligenza artificiale e l'apprendimento automatico.
# 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)
Passaggio 2: creare una catena di QA basata sul recupero
Ora che abbiamo il nostro archivio di vettori, possiamo creare una catena di QA basata sul recupero:
# Create a retrieval-based QA chain qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever())
Passaggio 3: interrogare il sistema
Ora possiamo interrogare il nostro sistema RAG:
query = "What are the main applications of machine learning?" result = qa.run(query) print(result)
Passaggio 4: creazione di un agente LLM
Sebbene il nostro semplice sistema RAG sia utile, è piuttosto limitato. Miglioriamolo creando un agente LLM in grado di eseguire attività più complesse e di ragionare sulle informazioni che recupera.
Un agente LLM è un sistema di intelligenza artificiale in grado di utilizzare strumenti e prendere decisioni sulle azioni da intraprendere. Creeremo un agente in grado non solo di rispondere alle domande, ma anche di eseguire ricerche web e calcoli di base.
Per prima cosa, definiamo alcuni strumenti per il nostro 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
)
Ora abbiamo un agente che può utilizzare il nostro sistema RAG, effettuare ricerche sul web ed eseguire calcoli. Proviamolo:
result = agent.run("What's the difference between supervised and unsupervised learning? Also, what's 15% of 80?")
print(result)
Questo agente dimostra un vantaggio chiave degli agenti LLM: possono combinare più strumenti e passaggi di ragionamento per rispondere a domande complesse.
Potenziare l'Agente con Tecniche RAG Avanzate
Sebbene il nostro attuale sistema RAG funzioni bene, esistono diverse tecniche avanzate che possiamo utilizzare per migliorarne le prestazioni:
a) Ricerca semantica con Dense Passage Retrieval (DPR)
Invece di utilizzare un semplice recupero basato sull'incorporamento, possiamo implementare DPR per una ricerca semantica più accurata:
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) Espansione della query
Possiamo utilizzare l'espansione della query per migliorare le prestazioni di recupero:
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) Perfezionamento iterativo
Possiamo implementare un processo di perfezionamento iterativo in cui l'agente può porre domande di follow-up per chiarire o espandere il suo recupero iniziale:
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
Implementazione di un sistema multi-agente
Per gestire attività più complesse, possiamo implementare un sistema multi-agente in cui diversi agenti sono specializzati in aree diverse. Ecco un semplice esempio:
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)
Questo sistema multi-agente consente la specializzazione e può gestire una gamma più ampia di query in modo più efficace.
Valutazione e ottimizzazione degli agenti RAG
Per garantire che il nostro agente RAG funzioni bene, dobbiamo implementare metriche di valutazione e tecniche di ottimizzazione:
a) Valutazione della pertinenza
Possiamo utilizzare metriche come BLEU, ROUGE o BERTScore per valutare la pertinenza dei documenti recuperati:
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) Valutazione della qualità della risposta
Possiamo utilizzare la valutazione umana o metriche automatizzate per valutare la qualità delle risposte:
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
Direzioni e sfide future
Guardando al futuro degli agenti RAG, emergono diverse direzioni e sfide entusiasmanti:
a) RAG multimodale: estende RAG per incorporare dati di immagini, audio e video.
b) RAG federato: Implementazione di RAG in basi di conoscenza distribuite che preservano la privacy.
c) Apprendimento continuo: Sviluppo di metodi che consentano agli agenti RAG di aggiornare le proprie basi di conoscenza e modelli nel tempo.
d) Considerazioni etiche: Affrontare pregiudizi, equità e trasparenza nei sistemi RAG.
e) Scalabilità: Ottimizzazione di RAG per applicazioni in tempo reale su larga scala.
Conclusione
Costruire agenti LLM per RAG da zero è un processo complesso ma gratificante. Abbiamo trattato le basi di RAG, implementato un sistema semplice, creato un agente LLM, lo abbiamo migliorato con tecniche avanzate, esplorato sistemi multi-agente e discusso strategie di valutazione e ottimizzazione.
