Der Beginn der KI-Revolution – eine Reise mit RAG und LangChain

Dieser Artikel führt die Leser durch eine erkenntnisreiche Erforschung der umwälzenden KI-Revolution und befasst sich mit den revolutionären Konzepten...

Im Zeitalter der künstlichen Intelligenz (KI) ist das Extrahieren von aussagekräftigem Material aus riesigen Datensätzen sowohl für Unternehmen als auch für Privatpersonen von entscheidender Bedeutung geworden. Hier kommt Retrieval-Augmented Generation (RAG) ins Spiel, eine bahnbrechende Entwicklung, welche die Fähigkeiten der KI enorm verbessert hat und es Systemen ermöglicht, nicht nur menschenähnlichen Text zu erzeugen, sondern auch relevante Informationen in Echtzeit abzurufen. Durch diese Kombination werden Antworten erzeugt, die sowohl kontextorientiert als auch detailreich sind.

Bevor wir in See stechen und die aufregende Reise über den weiten Ozean der künstlichen Intelligenz (KI) antreten, müssen wir unbedingt die drei Säulen verstehen, die als unsere Leitsterne fungieren werden: generative KI, große Sprachmodelle (engl. Large Language Models; LLMs), LangChain, Hugging Face und die nützliche Anwendung dieser RAG (Retrieval-Augmented Generation).

Große Sprachmodelle und generative KI: Die Motoren der Innovation

Im Mittelpunkt unserer Reise stehen große Sprachmodelle (LLMs) und generative KI – zwei starke Motoren, die das Innovationsschiff vorantreiben.

Große Sprachmodelle (LLMs)

LLMs wie u. a. Qwen und GPT sind die Text-Titanen, die in der Lage sind, menschenähnliche Sprache in riesengroßem Umfang zu verstehen und zu generieren. Diese Modelle wurden anhand von umfangreichen Textdatenkorpora trainiert, sodass sie kohärente und kontextuell relevante Textzeichenfolgen vorhersagen und erzeugen können. Sie sind das Rückgrat vieler Aufgaben, welche die Verarbeitung natürlicher Sprache umfassen, von der Übersetzung bis zur Erstellung von Inhalten.

Generative KI (GenAI)

Generative KI ist der kunstvolle Zauberer der Schöpfung im Reich der KI. Sie umfasst Technologien, die neue Dateninstanzen generieren, die den Trainingsdaten ähneln, wie Bilder, Musik und – für unsere Reise besonders wichtig – Text. In unserem Kontext bezieht sich generative KI auf die Fähigkeit der KI, neuartige und informative Antworten, Geschichten oder Ideen zu erzeugen, die es in dieser Form noch nie gegeben hat. Sie ermöglicht der KI, nicht nur die Vergangenheit nachzuahmen, sondern auch zu erfinden, zu innovieren und zu inspirieren.

LangChain: Ihre KI-Symphonie arrangieren

LangChain fungiert als Architekt unseres KI-Workflows und entwirft sorgfältig die Struktur, die eine nahtlose Integration und Interaktion zwischen verschiedenen KI-Komponenten ermöglicht. Dieses Framework vereinfacht den komplexen Prozess der Verkettung des Datenflusses aus intelligenten Subsystemen, einschließlich LLMs und Retrieval-Systemen, und macht Aufgaben wie Informationsextraktion und Verständnis natürlicher Sprache zugänglicher als je zuvor.

Hugging Face: Die KI-Modell-Metropole

Hugging Face ist eine geschäftige Metropole, in der KI-Modelle florieren. Dieser zentrale Hub bietet eine Vielzahl von vortrainierten Modellen, die als fruchtbarer Boden für die Erforschung und Anwendung maschinellen Lernens dienen. Um Zugang zu diesem Hub und seinen Ressourcen zu erhalten, müssen Sie ein Hugging Face-Konto erstellen. Sobald Sie diesen Schritt gemacht haben, öffnen sich für Sie die Tore zu einer weitläufigen Welt der KI – besuchen Sie einfach Hugging Face und melden Sie sich an, um das Abenteuer zu beginnen.

RAG: Nutzung von Vektordatenbanken für beschleunigte Intelligenz

Retrieval-Augmented Generation (RAG) ist ein ausgefeiltes KI-Verfahren, das die Erfindungskraft der generativen KI mit der Präzision des Informationsabrufs verbindet und so ein System schafft, das nicht nur sprachgewandt, sondern auch bestens informiert ist. Um das Potenzial und die Effizienz von RAG voll auszuschöpfen, werden Vektordatenbanken integriert – ein leistungsstarkes Tool zum schnellen Durchsuchen großer Informationsbestände. Hier finden Sie eine ausführlichere Beschreibung, wie RAG mit Vektordatenbanken arbeitet:

Abruf (Retrieval) über Vektordatenbanken: RAG beginnt seinen Prozess mit der Abfrage einer Vektordatenbank, die eingebettete Repräsentationen eines großen Informationskorpus enthält. Diese Einbettungen sind hochdimensionale Vektoren, die den wesentlichen Inhalt von Dokumenten oder Datenschnipseln beinhalten. Mithilfe von Vektordatenbanken kann RAG diese Einbettungen blitzschnell durchsuchen, um jene Inhalte zu finden, die für eine bestimmte Abfrage am relevantesten sind, ähnlich wie eine KI, die schnell durch eine digitale Bibliothek navigiert, um genau das richtige Buch zu finden.
Ergänzung (Augmentation) durch Kontext: Die relevanten Informationen, die aus der Vektordatenbank abgerufen werden, werden dann einem generativen Modell als kontextuelle Ergänzung zur Verfügung gestellt. Dieser Schritt versorgt die KI mit einer geballten Dosis an Informationen und verbessert so ihre Fähigkeit, Antworten zu erzeugen, die nicht nur kreativ, sondern auch kontextbezogen sind.
Erzeugung (Generation) von fachkundigen Antworten: Mit diesem Kontext bewaffnet, erzeugt das generative Modell Text. Im Gegensatz zu generativen Standardmodellen, die sich ausschließlich auf erlernte Muster stützen, berücksichtigt RAG die Details aus den abgerufenen Daten, was zu Ergebnissen führt, die sowohl einfallsreich als auch durch die abgerufenen Informationen begründet sind. Dadurch wird die Texterzeugung verbessert und liefert Antworten, die präziser und informationsreicher sind und den wahren Kontext widerspiegeln.

Die Integration von Vektordatenbanken ist der Schlüssel zur Effizienz der RAG. Herkömmliche Metadaten-Suchmethoden sind meist langsamer und ungenauer, Vektordatenbanken hingegen ermöglichen das nahezu sofortige Abrufen kontextrelevanter Informationen, selbst aus extrem großen Datenbeständen. Dieser Ansatz spart nicht nur wertvolle Zeit, sondern stellt auch sicher, dass die Antworten der KI auf den relevantesten und aktuellsten verfügbaren Informationen beruhen.

Die Fähigkeiten von RAG sind besonders bei Anwendungen wie Chatbots, digitalen Assistenten und anspruchsvollen Recherchetools von Vorteil – überall, wo die Bereitstellung präziser, zuverlässiger und kontextbezogener Informationen von entscheidender Bedeutung ist. Es geht nicht nur darum, Antworten zu erzeugen, die überzeugend klingen. Es geht darum, Inhalte zu generieren, die auf überprüfbaren Daten und realem Wissen basieren.

Nun da wir ein besseres Verständnis von LangChain, Hugging Face, LLMs, GenAI und der durch Vektordatenbanken optimierten RAG haben, stehen wir am Beginn eines Programmierabenteuers, das diese Technologien zum Leben erwecken wird. Das Python-Skript, mit dem wir uns befassen werden, stellt die Synergie dieser Elemente dar. Es liefert ein KI-System, das nicht nur mit Kreativität und Kontext reagieren kann, sondern auch mit einem tiefen Verständnis, das einst als reine Science-Fiction galt. Machen Sie sich bereit, zu programmieren und die transformierende Kraft von RAG mit Vektordatenbanken zu erleben.

Beginn der Programmierreise

Bevor Sie loslegen: Die Grundausstattung

Bevor wir uns auf diese technische Odyssee begeben, sollten wir sicherstellen, dass Sie alles Nötige bereit haben:

Ein Linux-Server ist besser mit einer Grafikkarte (GPU) – denn seien wir ehrlich, Geschwindigkeit ist wesentlich.
Python 3.6 oder höher – der Zauberstab der Programmierung.
pip oder Anaconda – Ihre praktischen Paketmanager.
Wenn eine GPU verwendet wird, dann mit NVIDIA-Treiber, CUDA-Toolkit und cuDNN – die heilige Dreifaltigkeit für die GPU-Beschleunigung.

Haben Sie das alles? Fabelhaft! Dann machen wir uns nun die Hände schmutzig (im übertragenen Sinne natürlich).

Den Code ausführen

Durch die sorgfältige Verwaltung Ihrer Python-Abhängigkeiten stellen Sie sicher, dass Ihr KI-Projekt auf einer stabilen und zuverlässigen Grundlage aufbaut. Wenn die Abhängigkeiten in Ordnung sind und die Umgebung korrekt eingerichtet ist, können Sie das Skript ausführen und die Leistungsfähigkeit von RAG und LangChain in Aktion erleben.

Jetzt können Sie das Python-Skript ausführen, um RAG in Aktion zu sehen.

Die Weichen stellen: Bibliotheken importieren und Variablen laden

Bevor wir uns der Erforschung der KI mit dem LangChain-Framework und der Transformers-Bibliothek von Hugging Face widmen können, müssen wir unbedingt eine sichere und gut konfigurierte Umgebung einrichten. Bei dieser Vorbereitung werden die erforderlichen Bibliotheken importiert und vertrauliche Informationen wie API-Schlüssel über Umgebungsvariablen verwaltet.

from torch import cuda
from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings
from transformers import AutoModelForCausalLM, AutoTokenizer
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
from transformers import pipeline
from dotenv import load_dotenv

load_dotenv()

Wenn Sie mit KI-Modellen von Hugging Face arbeiten, benötigen Sie häufig Zugriff auf die Hugging Face-API, für die ein API-Schlüssel erforderlich ist. Dieser Schlüssel ist Ihre eindeutige Kennung, wenn Sie Anfragen an Hugging Face-Dienste stellen, sodass Sie Modelle laden und in Ihren Anwendungen verwenden können.

Folgendes müssen Sie tun, um Ihre Umgebung sicher einzurichten:

Hugging Face-API-Schlüssel erhalten: Nachdem Sie Ihr Hugging Face-Konto erstellt haben, finden Sie Ihren API-Schlüssel in Ihren Kontoeinstellungen im Abschnitt „Zugriffstoken“.
API-Schlüssel schützen: Ihr API-Schlüssel ist eine vertrauliche Information und sollte geheim gehalten werden. Anstatt ihn in Ihre Skripte fest einzuprogrammieren, sollten Sie Umgebungsvariablen verwenden.
.env-Datei erstellen: Erstellen Sie eine Datei mit der Endung .env. In dieser Datei werden Ihre Umgebungsvariablen gespeichert.
API-Schlüssel in die .env-Datei einfügen: Öffnen Sie die .env-Datei mit einem Texteditor und fügen Sie Ihren Hugging Face-API-Schlüssel im folgenden Format ein:

HUGGINGFACE_API_KEY=your_api_key_here

Ersetzen Sie „your_api_key_here“ durch den tatsächlichen API-Schlüssel, den Sie von Hugging Face erhalten haben.

Modellpfad und Konfiguration definieren

modelPath = "sentence-transformers/all-mpnet-base-v2"
device = 'cuda' if cuda.is_available() else 'cpu'
model_kwargs = {'device': device}

Hier legen wir den Pfad zum vortrainierten Modell fest, das für Einbettungen verwendet wird. Wir konfigurieren auch die Geräteeinstellung und verwenden eine GPU für eine schnellere Rechenleistung, wenn diese zur Verfügung steht, ansonsten greifen wir auf die CPU zurück.

Hugging Face-Einbettungen und FAISS Vector Store initialisieren

embeddings = HuggingFaceEmbeddings(
    model_name=modelPath,
    model_kwargs=model_kwargs,
)

# Made up data, just for fun, but who knows in a future
vectorstore = FAISS.from_texts(
    ["Harrison worked at Alibaba Cloud"], embedding=embeddings
)

retriever = vectorstore.as_retriever()

Wir initialisieren eine Instanz von HuggingFaceEmbeddings mit unserem gewählten Modell und unserer gewählten Konfiguration. Anschließend erstellen wir mithilfe von FAISS einen Vektorspeicher, mit dem wir effiziente Ähnlichkeitssuchen in hochdimensionalen Räumen durchführen können. Wir instanziieren auch einen Retriever, der Informationen basierend auf den Einbettungen abruft.

Chat-Prompt-Vorlage einrichten

template = """Answer the question based only on the following context:
{context}
Question: {question}
"""

prompt = ChatPromptTemplate.from_template(template)

Hier definieren wir eine Chat-Prompt-Vorlage, die zur Strukturierung der Interaktion mit der KI verwendet wird. Sie enthält Platzhalter für den Kontext und eine Frage, die während der Ausführung der Kette dynamisch gefüllt werden.

Tokenizer und Sprachmodell vorbereiten

In der Welt der KI und der Verarbeitung natürlicher Sprache sind der Tokenizer und das Sprachmodell das dynamische Duo, das Text in sinnvolles Handeln verwandelt. Der Tokenizer zerlegt die Sprache in Teile, die das Modell verstehen kann, während das Sprachmodell basierend auf diesen Eingaben die Sprache vorhersagt und generiert. Auf unserer Reise verwenden wir die AutoTokenizer- und AutoModelForCausalLM-Klassen von Hugging Face, um diese Funktionen zu nutzen. Man darf jedoch nicht vergessen, dass es bei der Auswahl eines Sprachmodells keine Universallösung gibt.

Modellgröße und Rechenressourcen

Die Größe des Modells ist ein wichtiger, zu berücksichtigender Faktor. Größere Modelle wie Qwen-72B haben mehr Parameter, was im Allgemeinen bedeutet, dass sie komplexeren Text verstehen und erzeugen können. Sie erfordern jedoch auch mehr Rechenleistung. Wenn Sie mit High-End-GPUs und ausreichend Speicher ausgestattet sind, können Sie sich für diese größeren Modelle entscheiden, um ihre Fähigkeiten optimal zu nutzen.

Auf der anderen Seite sind kleinere Modelle wie Qwen-1.8B für Standard-Computerumgebungen viel handlicher. Selbst dieses winzige Modell sollte auf IoT und mobilen Geräten laufen können. Auch wenn sie möglicherweise die Feinheiten der Sprache nicht so gut erfassen wie ihre größeren Gegenstücke, bieten sie dennoch eine hervorragende Leistung und sind für diejenigen, die keine spezielle Hardware haben, leichter zugänglich.

Aufgabenspezifische Modelle

Ein weiterer zu berücksichtigender Punkt ist die Art Ihrer Aufgabe. Wenn Sie eine Konversations-KI entwickeln, kann die Verwendung eines Chat-spezifischen Modells wie Qwen-7B-Chat zu besseren Ergebnissen führen, da diese Modelle für Dialoge optimiert sind und die Nuancen von Gesprächen besser verarbeiten können als die Basismodelle.

Inferenzkosten

Größere Modelle stellen nicht nur höhere Anforderungen an Ihre Hardware, sondern können auch höhere Kosten verursachen, wenn Sie Cloud-basierte Dienste für die Ausführung Ihrer Modelle verwenden. Jede Inferenz beansprucht Verarbeitungszeit und Ressourcen, die sich summieren können, wenn Sie mit einem umfangreichen Modell arbeiten.

Qwen-Serie

Qwen-1.8B: ein kleineres Modell, das für Aufgaben geeignet ist, die weniger Rechenleistung erfordern. Geeignet für Prototyping und die Ausführung auf Rechnern ohne leistungsstarke GPUs.
Qwen-7B: ein mittelgroßes Modell, das eine gute Balance zwischen Leistung und Rechenanforderungen herstellt. Geeignet für verschiedene Aufgaben, einschließlich Textgenerierung und Beantwortung von Fragen.
Qwen-14B: ein größeres Modell, das komplexere Aufgaben mit einer größeren Nuance im Sprachverständnis und in der Sprachgenerierung bewältigen kann.
Qwen-72B: das größte Modell der Serie, das modernste Leistung für fortschrittliche KI-Anwendungen bietet, die ein tiefes Sprachverständnis erfordern.
Qwen-1.8B-Chat: ein Konversationsmodell, das speziell für die Entwicklung von Chatbots und anderen Dialogsystemen entworfen wurde.
Qwen-7B-Chat: Ähnlich wie Qwen-1.8B-Chat, jedoch mit erhöhter Kapazität zur Bearbeitung komplexerer Dialoge.
Qwen-14B-Chat: Ein High-End-Konversationsmodell, das anspruchsvolle Dialoginteraktionen ermöglicht.
Qwen-72B-Chat: das fortschrittlichste Konversationsmodell der Qwen-Serie, das außergewöhnliche Leistung für besonders anspruchsvolle Chat-Anwendungen bietet.

Die Entscheidung treffen

Wenn Sie entscheiden, welches Modell Sie verwenden möchten, sollten Sie die Vorteile eines größeren Modells gegen die verfügbaren Ressourcen und die spezifischen Anforderungen Ihres Projekts abwägen. Wenn Sie gerade erst anfangen oder ein Projekt mit kleinerem Maßstab entwickeln, ist möglicherweise ein kleineres Modell die beste Wahl. Wenn Ihre Anforderungen wachsen oder wenn Sie erweiterte Funktionen benötigen, sollten Sie auf ein größeres Modell zurückgreifen.

Denken Sie daran, dass die Qwen-Serie Open Source ist. Sie können also mit verschiedenen Modellen experimentieren, um zu sehen, welches am besten zu Ihrem Projekt passt. So könnte der Teil des Skripts für die Modellauswahl aussehen, wenn Sie sich für ein anderes Modell entscheiden:

# This can be changed to any of the Qwen models based on your needs and resources
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen-7B", trust_remote_code=True)
model_name_or_path = "Qwen/Qwen-7B"
model = AutoModelForCausalLM.from_pretrained(model_name_or_path,
                                             device_map="auto",
                                             trust_remote_code=True)

Wir laden einen Tokenizer und ein kausales Sprachmodell von Hugging Face mit den AutoTokenizer- und AutoModelForCausalLM-Klassen. Diese Komponenten sind entscheidend für die Verarbeitung von Input in natürlicher Sprache und die Erzeugung von Output.

Textgenerierungspipeline erstellen

Diese Pipeline ist so konzipiert, dass sie mithilfe eines Sprachmodells und eines Tokenizers, die zuvor geladen wurden, Text generiert. Lassen Sie uns die Parameter aufschlüsseln, um ihre Rollen bei der Steuerung des Verhaltens der Textgenerierung zu verstehen:

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=8192,
    do_sample=True,
    temperature=0.7,
    top_p=0.95,
    top_k=40,
    repetition_penalty=1.1
)

hf = HuggingFacePipeline(pipeline=pipe)

Erläuterung der Parameter in der Texterzeugungspipeline:

max_new_tokens (8192): Dieser Parameter gibt die maximale Anzahl von Token an, die in der Output generiert werden können. Token können Wörter, Zeichen oder Unterwörter sein, abhängig vom Tokenizer.
do_sample (True): Wenn dieser Parameter auf True gesetzt ist, ermöglicht er ein probabilistisches Sampling aus der Verteilung möglicher nächster vom Modell generierter Token. Dies führt zu Zufälligkeit und Vielfalt im generierten Text. Wenn der Parameter auf False gesetzt ist, wählt das Modell immer das wahrscheinlichste nächste Token aus, was zu bestimmteren und weniger abwechslungsreichen Output führt.
temperature (0.7): Der Temperaturparameter steuert, wie zufällig der Samplingprozess ist. Ein niedrigerer Temperaturwert (näher an 0) macht das Modell sicherer bei seiner Auswahl, was zu weniger zufälligem Output führt, während ein höherer Temperaturwert (näher an 1) mehr Zufälligkeit und Vielfalt fördert.
top_p (0.95): Dieser Parameter steuert das Nukleus-Sampling, ein Verfahren, das nur die wahrscheinlichsten Token mit einer kumulativen Wahrscheinlichkeit über dem Schwellenwert von top_p berücksichtigt. Das hilft dabei, Text zu generieren, der sowohl vielfältig als auch kohärent ist, und vermeidet die Aufnahme von Token mit sehr geringer Wahrscheinlichkeit, die den Text unsinnig machen könnten.
top_k (40): Top-k-Sampling beschränkt den Sampling-Pool auf die k wahrscheinlichsten nächsten Token. Dadurch wird die Auswahl von Token, die das Modell für die Generierung des nächsten Textabschnitts in Betracht zieht, weiter eingeschränkt, um sicherzustellen, dass der Output relevant und kohärent bleibt.
repetition_penalty (1.1): Dieser Parameter hält das Modell davon ab, dieselben Token oder Ausdrücke zu wiederholen, und fördert so interessanteren und vielfältigeren Text. Ein Wert größer als 1 bestraft und verringert somit die Wahrscheinlichkeit von Token, die bereits erschienen sind.

Nach dem Einrichten der Pipeline mit den gewünschten Parametern folgt die Codezeile:

hf = HuggingFacePipeline(pipeline=pipe)

Dadurch wird die Pipeline in eine HuggingFacePipeline verpackt. Diese Klasse ist Teil des LangChain-Frameworks und ermöglicht die nahtlose Integration der Pipeline in den Workflow von LangChain zum Entwickeln von KI-Anwendungen. Durch Verpacken der Pipeline können wir sie nun in Verbindung mit anderen Komponenten der LangChain, wie z. B. Retrievern und Parsern, verwenden, um komplexere KI-Systeme zu erstellen.

Die sorgfältige Auswahl dieser Parameter ermöglicht es Ihnen, das Verhalten der Textgenerierung an die spezifischen Bedürfnisse Ihrer Anwendung anzupassen – je nachdem, ob Sie kreativere und abwechslungsreichere Ergebnisse wollen oder einen konsequent kohärenten und zielgerichteten Text anstreben.

RAG-Kette erstellen und ausführen

Der folgende Code-Abschnitt stellt ein vollständiges End-to-End-RAG-System dar, bei dem die anfängliche Frage eine Suche nach relevanten Informationen einleitet, die anschließend zur Ergänzung des generativen Prozesses verwendet werden. Dies führt zu einer fundierten und kontextbezogenen Antwort auf die eingegebene Frage.

1. Kettenaufbau:

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | hf
    | StrOutputParser()
)

Folgendes läuft in diesem Teil des Codes ab:

Ein Retriever wird verwendet, um relevante Informationen basierend auf der Suchanfrage abzurufen. Die Aufgabe des Retrievers besteht darin, einen Datensatz oder eine Sammlung von Dokumenten zu durchsuchen, um jene Informationen zu finden, die für die gestellte Frage am relevantesten sind. Aus Gründen der Effizienz wird dabei wahrscheinlich eine Vektordatenbank verwendet.
RunnablePassthrough() ist eine Komponente, welche die Frage einfach ohne Änderung weitergibt. Dies deutet darauf hin, dass die Kette so konzipiert ist, dass sie die Frage direkt behandelt, wahrscheinlich genau so, wie sie von einem Benutzer eingegeben wurde.
Der Prompt wird hier nicht im Detail gezeigt, er dient jedoch wahrscheinlich als Vorlage oder eine Reihe von Anweisungen, welche die eingegebene Frage und den abgerufenen Kontext so formatiert, dass sie für die nächste Stufe in der Pipeline, nämlich das Hugging Face-Modell, geeignet sind.
Die Variable hf steht für die Hugging Face-Pipeline, bei der es sich vermutlich um ein vortrainiertes Sprachmodell handelt, das Antworten generieren kann. Diese Pipeline nimmt den formatierten Input aus dem vorherigen Schritt und verwendet ihre generativen Fähigkeiten, um eine Antwort zu erzeugen.
Der StrOutputParser() ist ein Output-Parser, dessen Aufgabe es ist, den rohen Output der Hugging Face-Pipeline in ein benutzerfreundlicheres Format umzuwandeln, vermutlich eine Zeichenfolge.

Die Verwendung des | (pipe) Operators legt nahe, dass dieser Code einen funktionalen Programmierstil verwendet, insbesondere das Konzept der Funktionskomposition oder ein Pipeline-Muster, bei dem der Output einer Funktion zum Input der nächsten wird.

2. Kettenaufruf:

results = chain.invoke("Where did Harrison work?")

In dieser Zeile wird die Kette mit einer bestimmten Frage aufgerufen: „Where did Harrison work?“ Dieser Aufruf löst die gesamte Abfolge von Vorgängen aus, die in der Kette definiert sind. Der Retriever sucht nach relevanten Informationen, die dann zusammen mit der Frage über den Prompt an das Hugging Face-Modell weitergegeben werden. Das Modell generiert eine Antwort basierend auf den Eingaben, die es erhält.

3. Ergebnisse ausgeben:

print(results)

Die generierte Antwort wird dann vom StrOutputParser() geparst und als Endergebnis zurückgegeben, das dann auf der Konsole oder einer anderen Schnittstelle ausgegeben wird.

Schließlich erstellen wir die RAG-Kette, indem wir den Retriever, die Prompt-Vorlage, die Hugging Face-Pipeline und den Output-Parser verknüpfen. Wir rufen die Kette mit unserer Frage auf, und die Ergebnisse werden ausgegeben.

Fazit: Ihr Tor zur meisterhaften KI-Beherrschung

Sie haben mit RAG und LangChain soeben einen riesigen Sprung in die Welt der KI gemacht. Durch Verstehen und Ausführen dieses Codes erschließen Sie das Potenzial, intelligente Systeme zu entwickeln, die auf noch nie dagewesene Weise mit Informationen argumentieren und interagieren können.

Dieser Artikel wurde ursprünglich in englischer Sprache verfasst. Den Originalartikel finden Sie hier.

Community