AGI
Erstellung von LLM-Agents für RAG von Grund auf und darüber hinaus: Ein umfassender Leitfaden
LLMs wie GPT-3, GPT-4 und ihre Open-Source-Pendants haben oft Schwierigkeiten mit der Abrufung aktueller Informationen und können manchmal Halluzinationen oder falsche Informationen generieren.
Retrieval-Augmented Generation (RAG) ist eine Technik, die die Leistung von LLMs mit externer Wissensabrufung kombiniert. RAG ermöglicht es uns, LLM-Antworten in tatsächlichen, aktuellen Informationen zu gründen, was die Genauigkeit und Zuverlässigkeit von AI-generiertem Inhalt erheblich verbessert.
In diesem Blogbeitrag werden wir erforschen, wie man LLM-Agents für RAG von Grund auf aufbaut, indem wir tief in die Architektur, Implementierungsdetails und erweiterte Techniken eintauchen. Wir werden alles abdecken, von den Grundlagen von RAG bis zur Erstellung komplexer Agenten, die in der Lage sind, komplexe Überlegungen und Aufgaben auszuführen.
Bevor wir mit dem Aufbau unseres LLM-Agents beginnen, sollten wir verstehen, was RAG ist und warum es wichtig ist.
RAG, oder Retrieval-Augmented Generation, ist ein hybrider Ansatz, der Informationsabrufung mit Textgenerierung kombiniert. In einem RAG-System:
- Wird eine Abfrage verwendet, um relevante Dokumente aus einer Wissensbasis abzurufen.
- Werden diese Dokumente dann zusammen mit der ursprünglichen Abfrage in ein Sprachmodell eingegeben.
- Generiert das Modell eine Antwort basierend auf der Abfrage und den abgerufenen Informationen.
RAG
Dieser Ansatz hat mehrere Vorteile:
- Verbesserte Genauigkeit: Durch die Grundierung von Antworten in abgerufenen Informationen reduziert RAG Halluzinationen und verbessert die faktische Genauigkeit.
- Aktuelle Informationen: Die Wissensbasis kann regelmäßig aktualisiert werden, was es dem System ermöglicht, auf aktuelle Informationen zuzugreifen.
- Transparenz: Das System kann Quellen für seine Informationen bereitstellen, was Vertrauen erhöht und eine Überprüfung ermöglicht.
Verständnis von LLM-Agents
Wenn Sie ein Problem ohne einfache Antwort haben, müssen Sie oft mehrere Schritte ausführen, sorgfältig nachdenken und sich daran erinnern, was Sie bereits versucht haben. LLM-Agents sind für genau diese Arten von Situationen in Sprachmodellanwendungen konzipiert. Sie kombinieren eine gründliche Datenanalyse, strategische Planung, Datenabrufung und die Fähigkeit, aus vergangenen Aktionen zu lernen, um komplexe Probleme zu lösen.
Was sind LLM-Agents?
LLM-Agents sind fortschrittliche KI-Systeme, die für die Erstellung komplexer Texte konzipiert sind, die sequenzielles Überlegen erfordern. Sie können vorausdenken, sich an vergangene Gespräche erinnern und verschiedene Werkzeuge verwenden, um ihre Antworten basierend auf der Situation und dem benötigten Stil anzupassen.
Betrachten Sie eine Frage aus dem Rechtsbereich wie: “Was sind die möglichen rechtlichen Konsequenzen eines bestimmten Vertragsbruchs in Kalifornien?” Ein grundlegender LLM mit einem RAG-System kann die notwendigen Informationen aus Rechtsdatenbanken abrufen.
Für ein detaillierteres Szenario: “Im Lichte neuer Datenschutzgesetze, welche rechtlichen Herausforderungen stellen Unternehmen und wie haben Gerichte diese Fragen behandelt?” Diese Frage geht über die bloße Nachschlagerei hinaus. Es geht darum, neue Regeln zu verstehen, ihre Auswirkungen auf verschiedene Unternehmen und die Reaktionen der Gerichte. Ein LLM-Agent würde diese Aufgabe in Teilaktionen aufteilen, wie z.B. das Abrufen der neuesten Gesetze, die Analyse historischer Fälle, die Zusammenfassung von Rechtsdokumenten und die Vorhersage von Trends basierend auf Mustern.
Komponenten von LLM-Agents
LLM-Agents bestehen im Allgemeinen aus vier Komponenten:
- Agent/Gehirn: Das Kernsprachmodell, das Sprache verarbeitet und versteht.
- Planung: Die Fähigkeit, zu überlegen, Aufgaben zu unterteilen und spezifische Pläne zu entwickeln.
- Speicher: Bewahrt Aufzeichnungen über vergangene Interaktionen und lernt daraus.
- Werkzeugverwendung: Integriert verschiedene Ressourcen, um Aufgaben auszuführen.
Agent/Gehirn
Im Kern eines LLM-Agents befindet sich ein Sprachmodell, das Sprache basierend auf großen Datenmengen verarbeitet und versteht, auf denen es trainiert wurde. Sie beginnen, indem Sie ihm einen spezifischen Prompt geben, der den Agenten anweist, wie er antworten, welche Werkzeuge er verwenden und welche Ziele er anstreben soll. Sie können den Agenten mit einer Persona anpassen, die für bestimmte Aufgaben oder Interaktionen geeignet ist, was seine Leistung verbessert.
Speicher
Die Speicher-Komponente hilft LLM-Agents, komplexe Aufgaben zu bewältigen, indem sie eine Aufzeichnung von vergangenen Aktionen aufrechterhält. Es gibt zwei Haupttypen von Speicher:
- Kurzzeit-Speicher: Funktioniert wie ein Notizblock, der laufende Diskussionen verfolgt.
- Langzeit-Speicher: Funktioniert wie ein Tagebuch, das Informationen aus vergangenen Interaktionen speichert, um Muster zu lernen und bessere Entscheidungen zu treffen.
Durch die Kombination dieser Speichertypen kann der Agent maßgeschneiderte Antworten anbieten und Benutzervorlieben über die Zeit hinweg merken, was zu einer verbundenen und relevanten Interaktion führt.
Planung
Die Planung ermöglicht es LLM-Agents, zu überlegen, Aufgaben in handhabbare Teile zu unterteilen und Pläne anzupassen, während die Aufgaben sich entwickeln. Die Planung umfasst zwei Hauptphasen:
- Plan-Formulierung: Die Aufgabe in kleinere Teil-Aufgaben zu unterteilen.
- Plan-Reflexion: Die Überprüfung und Bewertung des Plans, um Strategien zu verfeinern.
Methoden wie die Chain of Thought (CoT) und Tree of Thought (ToT) helfen bei diesem Zerlegungsprozess, indem sie es den Agenten ermöglichen, verschiedene Pfade zu erkunden, um ein Problem zu lösen.
Um tiefer in die Welt der KI-Agents einzutauchen, einschließlich ihrer aktuellen Fähigkeiten und Potenziale, lesen Sie “Auto-GPT & GPT-Engineer: Ein detaillierter Leitfaden zu den führenden KI-Agents von heute”
Einrichten der Umgebung
Um unseren RAG-Agenten aufzubauen, müssen wir unsere Entwicklungsumgebung einrichten. Wir werden Python und mehrere Schlüsselbibliotheken verwenden:
- LangChain: Für die Orchestrierung unseres LLM und der Abrufungskomponenten
- Chroma: Als unser Vektor-Speicher für Dokument-Embeddings
- OpenAI’s GPT-Modelle: Als unser Basis-LLM (Sie können dies durch ein Open-Source-Modell ersetzen, wenn bevorzugt)
- FastAPI: Für die Erstellung einer einfachen API, um mit unserem Agenten zu interagieren
Lassen Sie uns beginnen, unsere Umgebung einzurichten:
# Erstellen Sie eine neue virtuelle Umgebung python -m venv rag_agent_env source rag_agent_env/bin/activate # Unter Windows verwenden Sie `rag_agent_env\Scripts\activate` # Installieren Sie die erforderlichen Pakete pip install langchain chromadb openai fastapi uvicorn
Jetzt erstellen wir eine neue Python-Datei namens rag_agent.py und importieren die erforderlichen Bibliotheken:
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 # Setzen Sie Ihren OpenAI-API-Schlüssel os.environ["OPENAI_API_KEY"] = "Ihr-API-Schlüssel-hier";
Aufbau eines einfachen RAG-Systems
Jetzt, da wir unsere Umgebung eingerichtet haben, lassen Sie uns ein grundlegendes RAG-System aufbauen. Wir beginnen damit, eine Wissensbasis aus einer Reihe von Dokumenten zu erstellen, und verwenden diese dann, um Abfragen zu beantworten.
Schritt 1: Vorbereitung der Dokumente
Zuerst müssen wir unsere Dokumente laden und vorbereiten. Nehmen wir an, wir haben eine Textdatei namens knowledge_base.txt mit einigen Informationen über KI und maschinelles Lernen.
# Laden Sie das Dokument
loader = TextLoader("knowledge_base.txt")
documents = loader.load()
# Teilen Sie die Dokumente in Abschnitte auf
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)
# Erstellen Sie Embeddings
embeddings = OpenAIEmbeddings()
# Erstellen Sie einen Vektor-Speicher
vectorstore = Chroma.from_documents(texts, embeddings)
Schritt 2: Erstellen einer Abruf-basierten QA-Kette
Jetzt, da wir unseren Vektor-Speicher haben, können wir eine Abruf-basierte QA-Kette erstellen:
# Erstellen Sie eine Abruf-basierte QA-Kette qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever())
Schritt 3: Abfrage des Systems
Wir können jetzt unser RAG-System abfragen:
query = "Was sind die Hauptanwendungen von maschinellem Lernen?" result = qa.run(query) print(result)
Schritt 4: Erstellung eines LLM-Agents
Während unser einfaches RAG-System nützlich ist, ist es ziemlich begrenzt. Lassen Sie uns es verbessern, indem wir einen LLM-Agenten erstellen, der komplexere Aufgaben ausführen und über die abgerufenen Informationen nachdenken kann.
Ein LLM-Agent ist ein KI-System, das Werkzeuge verwenden und Entscheidungen über die zu ergreifenden Aktionen treffen kann. Wir werden einen Agenten erstellen, der nicht nur Fragen beantworten, sondern auch Web-Suchen und grundlegende Berechnungen durchführen kann.
Zuerst definieren wir einige Werkzeuge für unseren Agenten:
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 # Definieren Sie ein Rechenwerkzeug class CalculatorTool(BaseTool): name = "Calculator" description = "Nützlich, wenn Sie Fragen zu Mathematik beantworten müssen" def _run(self, query: str) try: return str(eval(query)) except: return "Ich konnte das nicht berechnen. Bitte stellen Sie sicher, dass Ihre Eingabe ein gültiger mathematischer Ausdruck ist." # Erstellen Sie Werkzeug-Instanzen search = DuckDuckGoSearchRun() calculator = CalculatorTool() # Definieren Sie die Werkzeuge tools = [Tool(name="Suche", func=search.run, description="Nützlich, wenn Sie Fragen zu aktuellen Ereignissen beantworten müssen"), Tool(name="RAG-QA", func=qa.run, description="Nützlich, wenn Sie Fragen zu KI und maschinellem Lernen beantworten müssen"), Tool(name="Calculator", func=calculator._run, description="Nützlich, wenn Sie mathematische Berechnungen durchführen müssen") ] # Initialisieren Sie den Agenten agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True )
Jetzt haben wir einen Agenten, der unser RAG-System verwenden, Web-Suchen durchführen und Berechnungen ausführen kann. Lassen Sie uns ihn testen:
result = agent.run("Was ist der Unterschied zwischen überwachtem und unüberwachtem Lernen? Außerdem, was ist 15% von 80?")
print(result)
Dieser Agent demonstriert einen wichtigen Vorteil von LLM-Agents: Sie können mehrere Werkzeuge und Überlegungsschritte kombinieren, um komplexe Abfragen zu beantworten.
Verbesserung des Agenten mit erweiterten RAG-Techniken
Während unser aktuelles RAG-System gut funktioniert, gibt es mehrere erweiterte Techniken, die wir verwenden können, um seine Leistung zu verbessern:
a) Semantische Suche mit Dense Passage Retrieval (DPR)
Anstelle der Verwendung von einfachen Embedding-basierten Abrufung können wir DPR für eine genauere semantische Suche implementieren:
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")
# Funktion, um Passagen zu codieren
def encode_passages(passages):
return context_encoder(passages, max_length=512, return_tensors="pt").pooler_output
# Funktion, um Abfragen zu codieren
def encode_query(query):
return question_encoder(query, max_length=512, return_tensors="pt").pooler_output
b) Abfrage-Erweiterung
Wir können Abfrage-Erweiterung verwenden, um die Abrufleistung zu verbessern:
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) Iterative Verfeinerung
Wir können einen iterativen Verfeinerungsprozess implementieren, bei dem der Agent Folgeabfragen stellen kann, um seine anfängliche Abrufung zu klären oder zu erweitern:
def iterative_retrieval(initial_query, max_iterations=3):
query = initial_query
for _ in range(max_iterations):
result = qa.run(query)
clarification = agent.run(f"Basierend auf diesem Ergebnis: '{result}', welche Folgeabfrage sollte ich stellen, um mehr spezifische Informationen zu erhalten?")
if clarification.lower().strip() == "none":
break
query = clarification
return result
# Verwenden Sie dies in Ihrem Agenten-Prozess
Implementierung eines Multi-Agenten-Systems
Um komplexere Aufgaben zu bewältigen, können wir ein Multi-Agenten-System implementieren, bei dem verschiedene Agenten sich auf unterschiedliche Bereiche spezialisieren. Hier ist ein einfaches Beispiel:
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)
# Erstellen Sie Spezialagenten
research_agent = SpecialistAgent("Forschung", [Tool(name="RAG-QA", func=qa.run, description="Für KI- und ML-Fragen")])
math_agent = SpecialistAgent("Math", [Tool(name="Calculator", func=calculator._run, description="Für Berechnungen")])
general_agent = SpecialistAgent("Allgemein", [Tool(name="Suche", func=search.run, description="Für allgemeine Abfragen")])
class Coordinator:
def __init__(self, agents):
self.agents = agents
def run(self, query):
# Bestimmen Sie, welchen Agenten zu verwenden ist
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 ['KI', 'maschinelles Lernen', 'tiefes Lernen']):
return self.agents['Forschung'].run(query)
else:
return self.agents['Allgemein'].run(query)
coordinator = Coordinator({'Forschung': research_agent, 'Math': math_agent, 'Allgemein': general_agent})
# Testen Sie das Multi-Agenten-System
result = coordinator.run("Was ist der Unterschied zwischen CNN und RNN? Außerdem, berechnen Sie 25% von 120.")
print(result)
Dieses Multi-Agenten-System ermöglicht es, sich auf bestimmte Bereiche zu spezialisieren und kann eine breitere Palette von Abfragen effektiver bewältigen.
Bewertung und Optimierung von RAG-Agents
Um sicherzustellen, dass unser RAG-Agent gut funktioniert, müssen wir Bewertungsmetriken und Optimierungstechniken implementieren:
a) Relevanz-Bewertung
Wir können Metriken wie BLEU, ROUGE oder BERTScore verwenden, um die Relevanz der abgerufenen Dokumente zu bewerten:
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) Antwort-Qualitäts-Bewertung
Wir können menschliche Bewertung oder automatisierte Metriken verwenden, um die Antwortqualität zu bewerten:
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()) # Verwenden Sie dies, um die Antworten Ihres Agenten zu bewerten
Zukünftige Richtungen und Herausforderungen
Wenn wir in die Zukunft von RAG-Agents blicken, ergeben sich mehrere spannende Richtungen und Herausforderungen:
a) Multimodale RAG: Erweiterung von RAG, um Bild-, Audio- und Video-Daten zu integrieren.
b) Föderale RAG: Implementierung von RAG über verteilte, datenschutzfreundliche Wissensbasen.
c) Fortlaufendes Lernen: Entwicklung von Methoden, um RAG-Agents zu ermöglichen, ihre Wissensbasen und Modelle über die Zeit zu aktualisieren.
d) Ethische Überlegungen: Bewältigung von Voreingenommenheit, Fairness und Transparenz in RAG-Systemen.
e) Skalierbarkeit: Optimierung von RAG für groß angelegte, Echtzeit-Anwendungen.
Schlussfolgerung
Die Erstellung von LLM-Agents für RAG von Grund auf ist ein komplexer, aber lohnender Prozess. Wir haben die Grundlagen von RAG abgedeckt, ein einfaches System implementiert, einen LLM-Agenten erstellt, ihn mit erweiterten Techniken verbessert, Multi-Agenten-Systeme erforscht und Bewertungs- und Optimierungstrategien diskutiert.
