Lokales LLM RAG Tutorial: Aufbau eines Retrieval ergänzten Generierungssystems mit Llama 3 und LlamaIndex

Einführung

Im Bereich der natürlichen Sprachverarbeitung (NLP) und der Informationssuche hat sich das Konzept der Retrieval Augmented Generation (RAG) als eine leistungsstarke Technik etabliert, die die Stärken großer Sprachmodelle (LLMs) mit der Fähigkeit kombiniert, relevante Informationen aus externen Quellen abzurufen. In diesem Tutorial werden Sie durch den Prozess des Aufbaus eines lokalen LLM RAG-Systems mit Hilfe des modernsten Llama 3-Sprachmodells von Meta AI und der LlamaIndex-Bibliothek geführt.

Llama 3 ist ein hochmodernes Sprachmodell, das von Meta AI entwickelt wurde und sich durch seine außergewöhnliche Leistungsfähigkeit bei verschiedenen NLP-Benchmarks sowie seine Eignung für den Dialogeinsatz auszeichnet. LlamaIndex hingegen ist eine Python-Bibliothek, die den Prozess des Aufbaus von Retrieval Augmented Generation-Systemen vereinfacht, indem sie eine nahtlose Integration zwischen LLMs und Informationssuchfähigkeiten bietet.

Indem Sie diesem Tutorial folgen, lernen Sie, wie Sie die notwendige Umgebung einrichten, Ihre Daten vorverarbeiten und indizieren, eine Abfrage-Engine erstellen und die Leistung von Llama 3 und LlamaIndex nutzen, um ein effizientes und genaues RAG-System aufzubauen. Ob Sie nun Forscher, Entwickler oder einfach nur neugierig auf die neuesten Entwicklungen im Bereich NLP sind, dieses Tutorial bietet Ihnen eine solide Grundlage, um die aufregende Welt der RAG-Systeme zu erkunden.

Verwendung von Anakin AI für No-Code RAG-Lösungen

Anakin AI ist eine leistungsstarke No-Code-Plattform, mit der Sie KI-gesteuerte Anwendungen erstellen können, ohne Code schreiben zu müssen. Es bietet eine visuelle Benutzeroberfläche zum Erstellen benutzerdefinierter KI-Modelle, zur Integration von Datenquellen und zum Bereitstellen von Anwendungen. Mit Anakin AI können Sie Ihr eigenes Retrieval Augmented Generation (RAG)-System aufbauen, ohne umfangreiche Programmierkenntnisse zu benötigen.

Die Plattform bietet eine Reihe von vorgefertigten Komponenten und Vorlagen, die Sie verwenden können, um Ihre RAG-Anwendung zu erstellen. Sie können Ihre Datenquellen, wie Dokumente, Datenbanken oder APIs, verbinden und die Abruf- und Generierungskomponenten nach Ihren Bedürfnissen konfigurieren.

Einer der Hauptvorteile bei der Verwendung von Anakin AI ist seine benutzerfreundliche Benutzeroberfläche, die auch für nicht technische Benutzer zugänglich ist. Sie können Komponenten per Drag & Drop verschieben, Einstellungen konfigurieren und Ihre KI-Anwendung mit nur wenigen Klicks bereitstellen. Darüber hinaus bietet Anakin AI Kollaborationsfunktionen, die es Teams ermöglichen, gemeinsam an der Entwicklung und Wartung von KI-Anwendungen zu arbeiten.

Obwohl Anakin AI nicht das gleiche Maß an Flexibilität und Anpassungsfähigkeit bietet wie der Code-Ansatz, bietet es einen bequemen und effizienten Weg, um KI-Anwendungen ohne umfangreiche Programmierkenntnisse zu erstellen. Dies kann insbesondere für Unternehmen oder Organisationen nützlich sein, die die Leistung von RAG-Systemen nutzen möchten, aber nicht über die Ressourcen oder das Fachwissen verfügen, um sie von Grund auf zu entwickeln.

Um mehr über Anakin AI und seine Funktionen zu erfahren, besuchen Sie https://anakin.ai.

Kostenlos starten

Schritt 1: Installation der erforderlichen Bibliotheken

Bevor wir in das Tutorial einsteigen, müssen wir sicherstellen, dass wir die erforderlichen Bibliotheken installiert haben. Öffnen Sie Ihr Terminal oder die Befehlszeile und führen Sie die folgenden Befehle aus:

pip install llama-index
pip install llama-index-llms-huggingface
pip install llama-index-embeddings-huggingface

Mit diesen Befehlen installieren Sie LlamaIndex und seine Abhängigkeiten, um mit Hugging Face-Modellen und Embeddings arbeiten zu können.

Schritt 2: Tokenizer und Stopping-IDs einrichten

Als Nächstes müssen wir den Tokenizer und die Stopping-IDs für das Llama 3-Modell einrichten. Importieren Sie in Ihrem Python-Skript oder Jupyter Notebook die erforderlichen Bibliotheken und laden Sie den Tokenizer:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "meta-llama/Meta-Llama-3-8B-Instruct",
    token=hf_token,
)

stopping_ids = [
    tokenizer.eos_token_id,
    tokenizer.convert_tokens_to_ids("<|eot_id|>"),
]

Ersetzen Sie hf_token durch Ihren Hugging Face-Token, falls Sie einen haben. Die Liste stopping_ids enthält die End-of-Sequence-Token-ID und eine spezielle Token-ID, die für das Anhalten des Generierungsprozesses verwendet wird.

Schritt 3: Einrichten des LLM mit HuggingFaceLLM

In diesem Schritt richten wir das Llama 3-Sprachmodell mithilfe der Klasse HuggingFaceLLM von LlamaIndex ein. Diese Klasse bietet eine bequeme Schnittstelle für die Arbeit mit Hugging Face-Modellen innerhalb des LlamaIndex-Ökosystems.

import torch
from llama_index.llms.huggingface import HuggingFaceLLM

llm = HuggingFaceLLM(
    model_name="meta-llama/Meta-Llama-3-8B-Instruct",
    model_kwargs={
        "token": hf_token,
        "torch_dtype": torch.bfloat16,
    },
    generate_kwargs={
        "do_sample": True,
        "temperature": 0.6,
        "top_p": 0.9,
    },
    tokenizer_name="meta-llama/Meta-Llama-3-8B-Instruct",
    tokenizer_kwargs={"token": hf_token},
    stopping_ids=stopping_ids,
)

In diesem Code-Schnipsel erstellen wir eine Instanz von HuggingFaceLLM mit dem entsprechenden Modellnamen, Modellparametern, Generierungsparametern, Tokenizer-Namen und Stopping-IDs. Passen Sie bei Bedarf die Generierungseinstellungen an Ihre Vorlieben an.

Schritt 4: Laden und Vorverarbeiten der Daten

Bevor wir einen Index erstellen können, müssen wir die Daten laden und vorverarbeiten, die wir für unser RAG-System verwenden möchten. LlamaIndex stellt eine bequeme Klasse SimpleDirectoryReader für diesen Zweck zur Verfügung.

from llama_index.core import SimpleDirectoryReader

documents = SimpleDirectoryReader(
    input_files=["Pfad/zu/Ihren/Daten/Dateien"]
).load_data()

Ersetzen Sie "Pfad/zu/Ihren/Daten/Dateien" durch den tatsächlichen Pfad zu Ihren Datendateien. Die Methode load_data() liest die Dateien ein und gibt eine Liste von Dokumenten zurück.

Schritt 5: Einrichten des Embedding-Modells

Um einen Index zu erstellen, müssen wir ein Embedding-Modell einrichten, das verwendet wird, um Vektorrepräsentationen der Dokumente zu generieren. LlamaIndex unterstützt verschiedene Embedding-Modelle, darunter solche von Hugging Face.

from llama_index.embeddings.huggingface import HuggingFaceEmbedding

embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5")

In diesem Beispiel verwenden wir das Modell BAAI/bge-small-en-v1.5 von Hugging Face. Sie können je nach Ihren Anforderungen und Rechenressourcen ein anderes Modell auswählen.

Schritt 6: Standard-LLM und Embedding-Modell festlegen

Anschließend müssen wir das Standard-LLM und das Embedding-Modell für LlamaIndex mithilfe der Klasse Settings festlegen.

from llama_index.core import Settings

Settings.embed_model = embed_model
Settings.llm = llm

Dieser Schritt stellt sicher, dass LlamaIndex standardmäßig das Llama 3-Sprachmodell und das angegebene Embedding-Modell verwendet.

Schritt 7: Index erstellen

Mit den eingerichteten Daten und Modellen können wir nun einen Index mit Hilfe der Klasse VectorStoreIndex von LlamaIndex erstellen.

from llama_index.core import VectorStoreIndex

index = VectorStoreIndex.from_documents(documents)

Die Methode from_documents() erstellt einen Index aus der zuvor geladenen Liste von Dokumenten.

Schritt 8: QueryEngine erstellen

Um den Index abzufragen und relevante Informationen abzurufen, müssen wir eine Instanz von QueryEngine erstellen.

query_engine = index.as_query_engine(similarity_top_k=3)

Die Methode as_query_engine() erstellt eine Instanz von QueryEngine aus dem Index. Der Parameter similarity_top_k gibt an, wie viele am besten bewertete Dokumente basierend auf Ähnlichkeitswerten abgerufen werden sollen.

Schritt 9: Index abfragen

Mit der eingerichteten QueryEngine können wir nun den Index abfragen und relevante Informationen abrufen.

response = query_engine.query("Was hat Paul Graham in seiner Jugend gemacht?")
print(response)

Ersetzen Sie den Abfragestring durch Ihre eigene Frage oder Aufforderung. Die Methode query() ruft die relevanten Dokumente ab und generiert eine Antwort mithilfe des Llama 3-Sprachmodells.

Schritt 10: Agenten und Tools erstellen (optional)

LlamaIndex bietet eine leistungsstarke agentenbasierte Schnittstelle, mit der Sie benutzerdefinierte Tools und Agenten für fortgeschrittenere Anwendungsfälle definieren können. Dieser Schritt ist optional, kann aber nützlich sein, wenn Sie die Funktionalität Ihres RAG-Systems erweitern möchten.

from llama_index.core.llms import ChatMessage
from llama_index.core.tools import BaseTool, FunctionTool
from llama_index.core.agent import ReActAgent

# Definieren Sie benutzerdefinierte Tools oder verwenden Sie QueryEngineTool mit der erstellten QueryEngine
query_engine_tool = QueryEngineTool(
    query_engine=query_engine,
    metadata=ToolMetadata(
        name="meine_query_engine",
        description="Liefert Informationen aus den indizierten Dokumenten.",
    ),
)

# Erstellen Sie eine Instanz von ReActAgent mit den Tools und LLM
agent = ReActAgent.from_tools([query_engine_tool], llm=llm, verbose=True)

# Stellen Sie eine Abfrage an den Agenten
response = agent.chat("Was hat Paul Graham in seiner Jugend gemacht?")
print(str(response))

In diesem Beispiel definieren wir ein QueryEngineTool unter Verwendung der zuvor erstellten QueryEngine-Instanz. Anschließend erstellen wir eine Instanz von ReActAgent mit dem Tool und dem Llama 3-Sprachmodell. Schließlich setzen wir eine Anfrage an den Agenten mit der Methode chat() ab.

Fazit

Herzlichen Glückwunsch! Sie haben erfolgreich ein lokales LLM RAG-System mit Llama 3 und LlamaIndex erstellt. Dieses Tutorial behandelte die wesentlichen Schritte, von der Einrichtung der Umgebung und der Vorverarbeitung der Daten bis hin zur Erstellung eines Index, der Erstellung einer Suchmaschine und der Abfrage des Systems.

RAG-Systeme sind leistungsstarke Werkzeuge, die die Stärken großer Sprachmodelle mit Informationssuchfähigkeiten kombinieren und so genauere und kontextuell relevante Antworten ermöglichen. Durch die Nutzung des hochmodernen Llama 3-Sprachmodells und der benutzerfreundlichen LlamaIndex-Bibliothek können Sie effiziente und effektive RAG-Systeme für eine Vielzahl von Anwendungen erstellen.

Experimentieren Sie gerne mit verschiedenen Datensätzen, Embedding-Modellen und Konfigurationen, um sie an Ihre spezifischen Anforderungen anzupassen. Betrachten Sie auch die Integration Ihres RAG-Systems mit anderen Komponenten wie Benutzeroberflächen oder APIs, um umfassendere und benutzerfreundlichere Anwendungen zu erstellen.

Viel Spaß beim Codieren und Erforschen der spannenden Welt der Retrieval Augmented Generation!

Hier ist ein Abschnitt über die Verwendung von Anakin AI als No-Code-KI-App-Builder als alternative RAG-Lösung: