Von Null auf Advanced Prompt Engineering mit Langchain in Python

Ein wichtiger Aspekt von Large Language Models (LLMs) ist die Anzahl der Parameter, die diese Modelle für das Lernen verwenden. Je mehr Parameter ein Modell hat, desto besser kann es die Beziehung zwischen Wörtern und Phrasen verstehen. Dies bedeutet, dass Modelle mit Milliarden von Parametern die Fähigkeit haben, verschiedene kreative Textformate zu generieren und offene und herausfordernde Fragen auf informative Weise zu beantworten.

LLMs wie ChatGPT, die das Transformer-Modell verwenden, sind befähigt, menschliche Sprache zu verstehen und zu generieren, was sie für Anwendungen nützlich macht, die ein Verständnis für natürliche Sprache erfordern. Sie haben jedoch auch ihre Grenzen, darunter veraltete Kenntnisse, die Unfähigkeit, mit externen Systemen zu interagieren, mangelndes Kontextverständnis und manchmal die Generierung von plausiblen, aber falschen oder unsinnigen Antworten, unter anderem.

Die Bekämpfung dieser Grenzen erfordert die Integration von LLMs mit externen Datenquellen und Fähigkeiten, was Komplexitäten mit sich bringen und umfangreiche Codier- und Datenhandhabungsfähigkeiten erfordern kann. Dies, kombiniert mit den Herausforderungen beim Verständnis von KI-Konzepten und komplexen Algorithmen, trägt zur Lernkurve bei, die mit der Entwicklung von Anwendungen mit LLMs verbunden ist.

Trotzdem könnte die Integration von LLMs mit anderen Tools, um LLM-basierte Anwendungen zu bilden, unser digitales Landschaftsbild neu definieren. Das Potenzial solcher Anwendungen ist riesig und umfasst die Verbesserung der Effizienz und Produktivität, die Vereinfachung von Aufgaben, die Verbesserung der Entscheidungsfindung und die Bereitstellung personalisierter Erfahrungen.

In diesem Artikel werden wir diese Probleme genauer untersuchen und fortgeschrittene Techniken der Prompt-Engineering mit Langchain erkunden, indem wir klare Erklärungen, praktische Beispiele und Schritt-für-Schritt-Anleitungen zur Implementierung davon anbieten.

Langchain, eine state-of-the-art-Bibliothek, bringt Bequemlichkeit und Flexibilität in die Gestaltung, Implementierung und Feinabstimmung von Prompts. Wenn wir die Prinzipien und Praktiken der Prompt-Engineering entfalten, werden Sie lernen, wie Sie die leistungsstarken Funktionen von Langchain nutzen können, um die Stärken von SOTA-Generative-AI-Modellen wie GPT-4 auszunutzen.

Verständnis von Prompts

Bevor wir in die technischen Details der Prompt-Engineering eintauchen, ist es wichtig, das Konzept von Prompts und ihrer Bedeutung zu verstehen.

Ein ‘Prompt‘ ist eine Sequenz von Token, die als Eingabe für ein Sprachmodell verwendet werden, um es anzuweisen, eine bestimmte Art von Antwort zu generieren. Prompts spielen eine entscheidende Rolle bei der Steuerung des Verhaltens eines Modells. Sie können die Qualität des generierten Textes beeinflussen, und wenn sie richtig gestaltet sind, können sie dem Modell helfen, aussagekräftige, genaue und kontextspezifische Ergebnisse zu liefern.

Prompt-Engineering ist die Kunst und Wissenschaft der Gestaltung effektiver Prompts. Das Ziel ist es, die gewünschte Ausgabe von einem Sprachmodell zu erhalten. Durch sorgfältige Auswahl und Strukturierung von Prompts kann man das Modell dazu anleiten, genauer und relevantere Antworten zu generieren. In der Praxis bedeutet dies, die Eingabephrasen zu feinabstimmen, um den Trainings- und Strukturvorlieben des Modells zu entsprechen.

Die Raffinesse der Prompt-Engineering reicht von einfachen Techniken, wie dem Füttern des Modells mit relevanten Schlüsselwörtern, bis hin zu fortgeschritteneren Methoden, die die Gestaltung komplexer, strukturierter Prompts beinhalten, die die internen Mechanismen des Modells zu seinem Vorteil nutzen.

Langchain: Das am schnellsten wachsende Prompt-Tool

LangChain, das im Oktober 2022 von Harrison Chase gegründet wurde, ist zu einem der meist bewerteten Open-Source-Frameworks auf GitHub im Jahr 2023 geworden. Es bietet eine vereinfachte und standardisierte Schnittstelle für die Integration von Large Language Models (LLMs) in Anwendungen. Es bietet auch eine funktionsreiche Schnittstelle für die Prompt-Engineering, die es Entwicklern ermöglicht, mit verschiedenen Strategien zu experimentieren und ihre Ergebnisse zu bewerten. Durch die Verwendung von LangChain können Sie Prompt-Engineering-Aufgaben effektiver und intuitiver durchführen.

LangFlow dient als Benutzeroberfläche für die Orchestrierung von LangChain-Komponenten in eine ausführbare Flussdiagramm, was eine schnelle Prototypisierung und Experimentierung ermöglicht.

LangChain füllt eine wichtige Lücke in der KI-Entwicklung für die Masse. Es ermöglicht eine Vielzahl von NLP-Anwendungen wie virtuelle Assistenten, Content-Generatoren, Frage-Antwort-Systeme und mehr, um eine Reihe von realen Problemen zu lösen.

Anstatt ein eigenständiges Modell oder Anbieter zu sein, vereinfacht LangChain die Interaktion mit verschiedenen Modellen und erweitert die Fähigkeiten von LLM-Anwendungen über die Grenzen eines einfachen API-Aufrufs hinaus.

Die Architektur von LangChain

LangChains Hauptkomponenten umfassen Model I/O, Prompt-Vorlagen, Speicher, Agenten und Ketten.

Model I/O

LangChain ermöglicht eine nahtlose Verbindung mit verschiedenen Sprachmodellen, indem es sie mit einer standardisierten Schnittstelle namens Model I/O umhüllt. Dies ermöglicht einen mühelosen Modellwechsel für Optimierung oder bessere Leistung. LangChain unterstützt verschiedene Sprachmodell-Anbieter, darunter OpenAI, HuggingFace, Azure, Fireworks und mehr.

Prompt-Vorlagen

Diese werden verwendet, um Interaktionen mit LLMs zu verwalten und zu optimieren, indem sie präzise Anweisungen oder Beispiele bereitstellen. Die Optimierung von Prompts verbessert die Modellleistung, und ihre Flexibilität trägt erheblich zum Eingabeprozess bei.

Ein einfaches Beispiel für eine Prompt-Vorlage:

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="Was sind die jüngsten Fortschritte im Bereich {subject}?")
print(prompt.format(subject="Natürliche Sprachverarbeitung"))

Wenn wir in der Komplexität voranschreiten, stoßen wir auf anspruchsvollere Muster in LangChain, wie das Reason-and-Act-(ReAct)-Muster. ReAct ist ein wichtiges Muster für die Ausführung von Aktionen, bei dem der Agent eine Aufgabe einem geeigneten Werkzeug zuweist, die Eingabe dafür anpasst und die Ausgabe parsen, um die Aufgabe auszuführen. Das folgende Python-Beispiel zeigt ein ReAct-Muster. Es demonstriert, wie ein Prompt in LangChain strukturiert ist, indem es eine Reihe von Gedanken und Aktionen verwendet, um ein Problem zu durchdenken und eine endgültige Antwort zu produzieren:

PREFIX = """Antworten Sie auf die folgende Frage mithilfe der bereitgestellten Werkzeuge:"""
FORMAT_INSTRUCTIONS = """Folgen Sie diesem Format:
Frage: {input_question}
Gedanke: Ihr erster Gedanke zur Frage
Aktion: Ihre gewählte Aktion aus [{tool_names}]
Aktionseingabe: Ihre Eingabe für die Aktion
Beobachtung: Das Ergebnis der Aktion"""
SUFFIX = """Los geht's!
Frage: {input}
Gedanke:{agent_scratchpad}"""

Speicher

Speicher ist ein kritischer Begriff in LangChain, der es LLMs und Werkzeugen ermöglicht, Informationen über die Zeit hinweg zu speichern. Dieses stateful-Verhalten verbessert die Leistung von LangChain-Anwendungen, indem es frühere Antworten, Benutzerinteraktionen, den Zustand der Umgebung und die Ziele des Agents speichert. Die ConversationBufferMemory- und ConversationBufferWindowMemory-Strategien helfen dabei, die gesamte oder kürzliche Konversation zu verfolgen. Für einen anspruchsvolleren Ansatz ermöglicht die ConversationKGMemory-Strategie die Kodierung der Konversation als Wissensgraph, der in Prompts oder zur Vorhersage von Antworten ohne Aufruf des LLMs verwendet werden kann.

Agenten

Ein Agent interagiert mit der Welt, indem er Aktionen und Aufgaben ausführt. In LangChain kombinieren Agenten Werkzeuge und Ketten zur Aufgabenausführung. Es kann eine Verbindung zur Außenwelt für die Informationsbeschaffung herstellen, um die Kenntnisse von LLMs zu erweitern und so ihre inhärenten Grenzen zu überwinden. Sie können entscheiden, Berechnungen an einen Rechner oder Python-Interpreter je nach Situation weiterzuleiten.

Agenten verfügen über Subkomponenten:

• Werkzeuge: Diese sind funktionale Komponenten.
• Werkzeugkästen: Sammlungen von Werkzeugen.
• Agenten-Ausführen: Dies ist der Ausführungsmechanismus, der es ermöglicht, zwischen Werkzeugen zu wählen.

Agenten in LangChain folgen auch dem Zero-Shot-ReAct-Muster, bei dem die Entscheidung nur auf der Werkzeugbeschreibung basiert. Dieser Mechanismus kann mit Speicher erweitert werden, um die gesamte Konversationshistorie zu berücksichtigen. Mit ReAct können Sie anstelle des LLMs, um Ihren Text zu vervollständigen, auffordern, in einem Gedanke/Aktions/Beobachtung-Loop zu antworten.

Ketten

Ketten, wie der Name schon sagt, sind Sequenzen von Operationen, die es der LangChain-Bibliothek ermöglichen, Sprachmodell-Eingaben und -Ausgaben nahtlos zu verarbeiten. Diese integralen Komponenten von LangChain bestehen grundlegend aus Links, die andere Ketten oder Primitive wie Prompts, Sprachmodelle oder Hilfsprogramme sein können.

Stellen Sie sich eine Kette als eine Förderband in einer Fabrik vor. Jeder Schritt auf diesem Band stellt eine bestimmte Operation dar, die zum Beispiel das Aufrufen eines Sprachmodells, das Anwenden einer Python-Funktion auf einen Text oder das Auffordern des Modells in einer bestimmten Weise sein kann.

LangChain kategorisiert seine Ketten in drei Arten: Utility-Ketten, generische Ketten und Combine-Documents-Ketten. Wir werden uns auf Utility- und generische Ketten für unsere Diskussion konzentrieren.

• Utility-Ketten sind speziell für die Extraktion präziser Antworten von Sprachmodellen für eng definierte Aufgaben konzipiert. Zum Beispiel betrachten wir die LLMMathChain. Diese Utility-Kette ermöglicht es Sprachmodellen, mathematische Berechnungen durchzuführen. Sie akzeptiert eine Frage in natürlicher Sprache, und das Sprachmodell generiert im Gegenzug einen Python-Code-Snippet, das dann ausgeführt wird, um die Antwort zu produzieren.
• Generische Ketten dienen hingegen als Bausteine für andere Ketten, können aber nicht direkt allein verwendet werden. Diese Ketten, wie die LLMChain, sind grundlegend und werden oft mit anderen Ketten kombiniert, um komplexe Aufgaben zu erfüllen. Zum Beispiel wird die LLMChain häufig verwendet, um ein Sprachmodell-Objekt zu befragen, indem es die Eingabe basierend auf einer bereitgestellten Prompt-Vorlage formatiert und sie dann an das Sprachmodell weiterleitet.

Schritt-für-Schritt-Implementierung der Prompt-Engineering mit Langchain

Wir werden Sie durch den Prozess der Implementierung der Prompt-Engineering mit Langchain führen. Bevor Sie fortfahren, stellen Sie sicher, dass Sie die notwendige Software und Pakete installiert haben.

Sie können von beliebten Tools wie Docker, Conda, Pip und Poetry profitieren, um LangChain einzurichten. Die relevanten Installationsdateien für jede dieser Methoden finden Sie im LangChain-Repository unter https://github.com/benman1/generative_ai_with_langchain. Dies umfasst ein Dockerfile für Docker, ein requirements.txt für Pip, ein pyproject.toml für Poetry und eine langchain_ai.yml-Datei für Conda.

In unserem Artikel werden wir Pip, den Standard-Paketmanager für Python, verwenden, um die Installation und Verwaltung von Drittanbieter-Bibliotheken zu erleichtern. Wenn Pip nicht in Ihrer Python-Verteilung enthalten ist, können Sie es installieren, indem Sie den Anweisungen auf https://pip.pypa.io/ folgen.

Um eine Bibliothek mit Pip zu installieren, verwenden Sie den Befehl pip install Bibliotheksname.

Allerdings verwaltet Pip keine Umgebungen selbst. Um mit verschiedenen Umgebungen umzugehen, verwenden wir das Tool virtualenv.

Im nächsten Abschnitt werden wir uns mit Modellintegrationen befassen.

Schritt 1: Einrichten von Langchain

Zuerst müssen Sie das Langchain-Paket installieren. Wir verwenden das Windows-Betriebssystem. Führen Sie den folgenden Befehl in Ihrem Terminal aus, um es zu installieren:

pip install langchain

Schritt 2: Importieren von Langchain und anderen notwendigen Modulen

Als Nächstes importieren Sie Langchain zusammen mit anderen notwendigen Modulen. Hier importieren wir auch die Transformers-Bibliothek, die umfassend für NLP-Aufgaben verwendet wird.

import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Schritt 3: Laden von vorgefertigten Modellen

Open AI

OpenAI-Modelle können über die LangChain-Bibliothek oder die OpenAI-Python-Client-Bibliothek einfach verwendet werden. Bemerkenswerterweise bietet OpenAI eine Embedding-Klasse für Text-Embedding-Modelle. Zwei wichtige LLM-Modelle sind GPT-3.5 und GPT-4, die sich hauptsächlich in der Tokenlänge unterscheiden. Die Preise für jedes Modell finden Sie auf der OpenAI-Website. Es gibt jedoch anspruchsvollere Modelle wie GPT-4-32K, die eine höhere Tokenakzeptanz haben, deren Verfügbarkeit über die API jedoch nicht immer garantiert ist.

Der Zugriff auf diese Modelle erfordert einen OpenAI-API-Schlüssel. Dies kann durch die Erstellung eines Kontos auf der OpenAI-Plattform, die Einrichtung von Abrechnungsinformationen und die Generierung eines neuen geheimen Schlüssels erfolgen.

import os
os.environ["OPENAI_API_KEY"] = 'Ihr-OpenAI-Token'

Nachdem Sie den Schlüssel erfolgreich erstellt haben, können Sie ihn als Umgebungsvariable (OPENAI_API_KEY) setzen oder ihn während der Klassenerstellung als Parameter übergeben.

Betrachten Sie ein LangChain-Skript, das die Interaktion mit den OpenAI-Modellen demonstriert:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# Das LLM nimmt einen Prompt als Eingabe und gibt eine Vervollständigung aus
prompt = "Wer ist der Präsident der Vereinigten Staaten von Amerika?"
completion = llm(prompt)

Der derzeitige Präsident der Vereinigten Staaten von Amerika ist Joe Biden.

In diesem Beispiel wird ein Agent initialisiert, um Berechnungen durchzuführen. Der Agent nimmt eine Eingabe, eine einfache Additionsaufgabe, verarbeitet sie mithilfe des bereitgestellten OpenAI-Modells und gibt das Ergebnis zurück.

Hugging Face

Hugging Face ist eine KOSTENLOSE Transformers-Python-Bibliothek, kompatibel mit PyTorch, TensorFlow und JAX, und enthält Implementierungen von Modellen wie BERT, T5 usw.

Hugging Face bietet auch den Hugging Face Hub, eine Plattform für die Bereitstellung von Code-Repositorys, Machine-Learning-Modellen, Datensätzen und Webanwendungen.

Um Hugging Face als Anbieter für Ihre Modelle zu verwenden, benötigen Sie ein Konto und API-Schlüssel, die Sie von ihrer Website erhalten können. Der Token kann in Ihrer Umgebung als HUGGINGFACEHUB_API_TOKEN verfügbar gemacht werden.

Betrachten Sie das folgende Python-Snippet, das ein Open-Source-Modell von Google, das Flan-T5-XXL-Modell, verwendet:

from langchain.llms import HuggingFaceHub

llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64}, repo_id="google/flan-t5-xxl")
prompt = "In welchem Land liegt Tokio?"
completion = llm(prompt)
print(completion)

Dieses Skript nimmt eine Frage als Eingabe und gibt eine Antwort aus, die die Kenntnisse und Vorhersagefähigkeiten des Modells demonstriert.

Schritt 4: Grundlegende Prompt-Engineering

Um zu beginnen, werden wir einen einfachen Prompt generieren und sehen, wie das Modell darauf reagiert.

prompt = 'Übersetzen Sie den folgenden englischen Text ins Französische: "{0}"'
input_text = 'Hallo, wie geht es Ihnen?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

In dem obigen Code-Snippet geben wir einen Prompt, um englischen Text ins Französische zu übersetzen. Das Sprachmodell versucht dann, den gegebenen Text basierend auf dem Prompt zu übersetzen.

Schritt 5: Fortgeschrittenes Prompt-Engineering

Während der obige Ansatz gut funktioniert, nutzt er nicht die volle Kraft der Prompt-Engineering aus. Lassen Sie uns es verbessern, indem wir komplexere Prompt-Strukturen einführen.

prompt = 'Als hochqualifizierter französischer Übersetzer übersetzen Sie den folgenden englischen Text ins Französische: "{0}"'
input_text = 'Hallo, wie geht es Ihnen?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

In diesem Code-Snippet modifizieren wir den Prompt, um vorzuschlagen, dass die Übersetzung von einem ‘hochqualifizierten französischen Übersetzer’ durchgeführt wird. Die Änderung des Prompts kann zu verbesserten Übersetzungen führen, da das Modell nun eine Expertenrolle annimmt.

Erstellung eines akademischen Literatur-Frage-und-Antwort-Systems mit Langchain

Wir werden ein akademisches Literatur-Frage-und-Antwort-System mit LangChain erstellen, das Fragen zu kürzlich veröffentlichten akademischen Artikeln beantworten kann.

Zuerst müssen wir unsere Umgebung einrichten, indem wir die notwendigen Abhängigkeiten installieren.

pip install langchain arxiv openai transformers faiss-cpu

Nach der Installation erstellen wir ein neues Python-Notebook und importieren die notwendigen Bibliotheken:

from langchain.llms import OpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.docstore.document import Document
import arxiv

Der Kern unseres Frage-und-Antwort-Systems ist die Fähigkeit, relevante akademische Artikel im Bereich der Natürlichen Sprachverarbeitung (NLP) mithilfe der arXiv-Datenbank abzurufen. Um dies zu tun, definieren wir eine Funktion get_arxiv_data(max_results=10). Diese Funktion sammelt die Zusammenfassungen der neuesten NLP-Artikel von arXiv und kapselt sie in LangChain-Dokument-Objekte, wobei die Zusammenfassung als Inhalt und die eindeutige Eintrag-ID als Quelle verwendet wird.

Wir werden die arXiv-API verwenden, um kürzlich veröffentlichte Artikel im Bereich NLP abzurufen:

def get_arxiv_data(max_results=10):
search = arxiv.Search(
query="NLP",
max_results=max_results,
sort_by=arxiv.SortCriterion.SubmittedDate,
)

documents = []

for result in search.results():
documents.append(Document(
page_content=result.summary,
metadata={"source": result.entry_id},
))

return documents

Diese Funktion ruft die Zusammenfassungen der neuesten NLP-Artikel von arXiv ab und wandelt sie in LangChain-Dokument-Objekte um. Wir verwenden die Artikelzusammenfassung und die eindeutige Eintrag-ID (URL zum Artikel) als Inhalt und Quelle.

def print_answer(question):
print(
chain(
{
"input_documents": sources,
"question": question,
},
return_only_outputs=True,
)["output_text"]
)

Lassen Sie uns nun unsere Korpus und LangChain einrichten:

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(temperature=0))

Mit unserem akademischen Frage-und-Antwort-System jetzt bereit, können wir es testen, indem wir eine Frage stellen:

print_answer("Was sind die jüngsten Fortschritte in der NLP?")

Die Ausgabe wird die Antwort auf Ihre Frage sein, wobei die Quellen, aus denen die Informationen stammen, angegeben sind. Zum Beispiel:

Jüngste Fortschritte in der NLP umfassen die Entwicklung von Retriever-ergänzten Anweisungsfolgemodellen für Informationsabrufaufgaben wie Fragebeantwortung (QA). Diese Modelle können an verschiedene Informationsdomänen und Aufgaben angepasst werden, ohne dass eine weitere Feinabstimmung erforderlich ist. Allerdings haben sie oft Schwierigkeiten, sich an das bereitgestellte Wissen zu halten, und können in ihren Antworten halluzinieren. Ein weiterer Fortschritt ist die Einführung eines Rechenframeworks zur Lösung von Wechselstrom-Optimalleistungsflussproblemen (ACOPF) mithilfe von Grafikprozessoren (GPUs). Dieser Ansatz nutzt eine einzelne Anweisung, mehrere Daten (SIMD)-Abstraktion nichtlinearer Programme (NLP) und wendet eine kondensierte Raum-Innenpunkt-Methode (IPM) mit einer Ungleichheitsrelaxierungsstrategie an. Diese Strategie ermöglicht die Faktorisierung der KKT-Matrix ohne numerische Schaltung, was zuvor die Parallelisierung der IPM-Algorithmen behindert hat.
QUellen: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Mit dem Code abgeschlossen, haben wir jetzt ein leistungsfähiges Werkzeug, um die neueste akademische Literatur im Bereich NLP zu befragen.

Jüngste Fortschritte in der NLP umfassen die Verwendung von tiefen neuronalen Netzen (DNNs) für automatische Textanalyse und NLP-Aufgaben wie Rechtschreibprüfung, Spracherkennung, Entitätenerkennung, Autorenerkennung, Fragebeantwortung und andere Aufgaben.
QUellen: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Ein Token in GPT-4 kann so kurz wie ein einzelnes Zeichen oder so lang wie ein einzelnes Wort sein. Zum Beispiel kann GPT-4-32K bis zu 32.000 Token in einem einzigen Lauf verarbeiten, während GPT-4-8K und GPT-3.5-Turbo 8.000 bzw. 4.000 Token unterstützen. Es ist jedoch wichtig zu beachten, dass jede Interaktion mit diesen Modellen mit einem Kostenfaktor verbunden ist, der direkt proportional zur Anzahl der verarbeiteten Token ist, sei es Eingabe oder Ausgabe.

Im Kontext unseres Frage-und-Antwort-Systems bedeutet dies, dass, wenn ein Stück akademischer Literatur die maximale Token-Grenze überschreitet, das System nicht in der Lage sein wird, es in seiner Gesamtheit zu verarbeiten, was die Qualität und Vollständigkeit der Antworten beeinträchtigen kann. Um dieses Problem zu umgehen, kann der Text in kleinere Teile aufgeteilt werden, die die Token-Grenze einhalten.

FAISS (Facebook AI Similarity Search) hilft dabei, die relevantesten Textteile in Bezug auf die Benutzerfrage schnell zu finden. Es erstellt eine Vektor-Darstellung jedes Textteils und verwendet diese Vektoren, um die Teile zu identifizieren und abzurufen, die dem Vektor der Benutzerfrage am ähnlichsten sind.

Es ist wichtig zu beachten, dass selbst mit dem Einsatz von Tools wie FAISS die Notwendigkeit, den Text in kleinere Teile aufzuteilen, aufgrund von Token-Beschränkungen manchmal zu einem Verlust des Kontexts führen kann, was die Qualität der Antworten beeinträchtigt. Daher ist eine sorgfältige Verwaltung und Optimierung der Token-Nutzung von entscheidender Bedeutung, wenn man mit diesen großen Sprachmodellen arbeitet.

pip install faiss-cpu langchain CharacterTextSplitter

Nachdem Sie sich vergewissert haben, dass die oben genannten Bibliotheken installiert sind, führen Sie aus

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.faiss import FAISS
from langchain.text_splitter import CharacterTextSplitter
documents = get_arxiv_data(max_results=10) # Wir können jetzt mehr Daten verwenden
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
for chunk in splitter.split_text(document.page_content):
document_chunks.append(Document(page_content=chunk, metadata=document.metadata))

search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())

chain = load_qa_with_sources_chain(OpenAI(temperature=0))

def print_answer(question):
print(
chain(
{
"input_documents": search_index.similarity_search(question, k=4),
"question": question,
},
return_only_outputs=True,
)["output_text"]
)

Mit dem Code abgeschlossen, haben wir jetzt ein leistungsfähiges Werkzeug, um die neueste akademische Literatur im Bereich NLP zu befragen.

Jüngste Fortschritte in der NLP umfassen die Verwendung von tiefen neuronalen Netzen (DNNs) für automatische Textanalyse und NLP-Aufgaben wie Rechtschreibprüfung, Spracherkennung, Entitätenerkennung, Autorenerkennung, Fragebeantwortung und andere Aufgaben.
QUellen: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Schlussfolgerung

Die Integration von Large Language Models (LLMs) in Anwendungen hat die Akzeptanz in verschiedenen Bereichen beschleunigt, einschließlich Sprachübersetzung, Sentiment-Analyse und Informationsabruf. Prompt-Engineering ist ein leistungsfähiges Werkzeug, um das volle Potenzial dieser Modelle auszuschöpfen, und Langchain ist führend bei der Vereinfachung dieser komplexen Aufgabe. Seine standardisierte Schnittstelle, flexible Prompt-Vorlagen, robuste Modellintegration und die innovative Verwendung von Agenten und Ketten gewährleisten optimale Ergebnisse für die Leistung von LLMs.

Allerdings ist es wichtig, einige Tipps zu beachten. Wenn Sie LangChain verwenden, ist es wichtig zu verstehen, dass die Qualität der Ausgabe stark von der Formulierung des Prompts abhängt. Das Experimentieren mit verschiedenen Prompt-Stilen und -Strukturen kann zu verbesserten Ergebnissen führen. Es ist auch wichtig zu beachten, dass LangChain eine Vielzahl von Sprachmodellen unterstützt, jedes mit seinen Stärken und Schwächen. Die Auswahl des richtigen Modells für Ihre spezifische Aufgabe ist von entscheidender Bedeutung. Schließlich ist es wichtig, daran zu denken, dass die Verwendung dieser Modelle mit Kostenüberlegungen verbunden ist, da die Token-Verarbeitung direkt die Kosten der Interaktionen beeinflusst.

Wie in der Schritt-für-Schritt-Anleitung gezeigt, kann LangChain leistungsfähige Anwendungen wie das akademische Literatur-Frage-und-Antwort-System antreiben. Mit einer wachsenden Benutzercommunity und zunehmender Bedeutung in der Open-Source-Landschaft verspricht LangChain ein wichtiger Schlüssel zu sein, um das volle Potenzial von LLMs wie GPT-4 zu nutzen.