Von Null auf Hundert: Erweiterte Prompt-Engineering mit Langchain in Python

Eine wichtige 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 Beziehungen 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 eine informative Weise zu beantworten.

LLMs wie ChatGPT, die das Transformer-Modell verwenden, sind in der Lage, menschliche Sprache zu verstehen und zu generieren, was sie für Anwendungen nützlich macht, die ein Verständnis der natürlichen Sprache erfordern. Allerdings haben sie auch ihre Einschränkungen, 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.

Um diese Einschränkungen zu überwinden, ist es notwendig, LLMs mit externen Datenquellen und Fähigkeiten zu integrieren, was Komplexitäten und umfangreiche Codier- und Datenverwaltungsfähigkeiten erfordern kann. Dies, kombiniert mit den Herausforderungen, AI-Konzepte und komplexe Algorithmen zu verstehen, 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-gesteuerte 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 tiefer in die Probleme eintauchen und erweiterte Techniken der Prompt-Engineering mit Langchain erkunden, klare Erklärungen, praktische Beispiele und Schritt-für-Schritt-Anleitungen zur Implementierung liefern.

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 man Langchains leistungsstarke Funktionen nutzt, um die Stärken von SOTA-Generative-AI-Modellen wie GPT-4 zu nutzen.

Verständnis von Prompts

Bevor wir in die technischen Aspekte der Prompt-Engineering eintauchen, ist es wichtig, das Konzept von Prompts und ihre 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, effektive Prompts zu entwerfen. Das Ziel ist, die gewünschte Ausgabe von einem Sprachmodell zu erhalten. Durch sorgfältige Auswahl und Strukturierung von Prompts kann man das Modell dazu bringen, genauer und relevantere Antworten zu generieren. In der Praxis bedeutet dies, die Eingabephrasen zu feinabstimmen, um den Trainings- und Strukturvorurteilen des Modells zu entsprechen.

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

Langchain: Das am schnellsten wachsende Prompt-Tool

LangChain, das im Oktober 2022 von Harrison Chase gestartet 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, verschiedene Strategien auszuprobieren 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, ermöglicht schnelles Prototyping und Experimentieren.

LangChain füllt eine wichtige Lücke in der AI-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 Einschränkungen 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 reibungslosen 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:

<p>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"))</p>

Wenn wir die Komplexität vorantreiben, stoßen wir auf komplexere 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 zu erfüllen. 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 = """Answer the following question using the given tools:"""
FORMAT_INSTRUCTIONS = """Follow this format:
Question: {input_question}
Thought: your initial thought on the question
Action: your chosen action from [{tool_names}]
Action Input: your input for the action
Observation: the action's outcome"""
SUFFIX = """Start!
Question: {input}
Thought:{agent_scratchpad}"""

Speicher

Speicher ist ein entscheidender Aspekt 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, den vollständigen oder aktuellen Teil eines Gesprächs zu verfolgen. Für einen anspruchsvolleren Ansatz ermöglicht die ConversationKGMemory-Strategie die Kodierung des Gesprächs 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 für die Aufgabenausführung. Es kann eine Verbindung zur Außenwelt herstellen, um Informationen zu beschaffen und die Kenntnisse des LLMs zu erweitern, um dessen inhärente Einschränkungen zu überwinden. Sie können entscheiden, Berechnungen an einen Rechner oder Python-Interpreter je nach Situation weiterzuleiten.

Agenten sind mit Subkomponenten ausgestattet:

• Werkzeuge: Diese sind funktionale Komponenten.
• Werkzeugkästen: Sammlungen von Werkzeugen.
• Agent-Executoren: 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 Gesprächshistorie zu berücksichtigen. Mit ReAct können Sie anstelle des Autocomplete des Modells auffordern, in einem Gedanken/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 Hilfsfunktionen 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 das Aufrufen eines Sprachmodells, das Anwenden einer Python-Funktion auf einen Text oder das Anfordern des Modells in einer bestimmten Weise umfassen kann.

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

• Utility-Ketten sind speziell dafür ausgelegt, präzise Antworten von Sprachmodellen für eng definierte Aufgaben zu extrahieren. 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.
• Generic-Ketten dienen als Bausteine für andere Ketten, können aber nicht direkt selbstständig 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 abfragen, indem es die Eingabe basierend auf einer bereitgestellten Prompt-Vorlage formatiert und 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 beliebte Tools wie Docker, Conda, Pip und Poetry für die Einrichtung von LangChain nutzen. Die relevanten Installationsdateien für jede dieser Methoden finden Sie im LangChain-Repository unter https://github.com/benman1/generative_ai_with_langchain. Dazu gehören 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 durch Befolgen der Anweisungen auf https://pip.pypa.io/ installieren.

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

pip verwaltet jedoch keine Umgebungen selbst. Um mit verschiedenen Umgebungen zu arbeiten, verwenden wir das Tool virtualenv.

In der nächsten Sektion werden wir uns mit Modell-Integrationen 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.

<p>import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Schritt 3: Laden von vorgebildeten Modellen

Open AI

OpenAI-Modelle können bequem mit der LangChain-Bibliothek oder der OpenAI-Python-Client-Bibliothek verwendet werden. OpenAI bietet 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 auch komplexere 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.

<p>import os
os.environ["OPENAI_API_KEY"] = 'Ihr-OpenAI-Token'</p>

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

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

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

<p>Der aktuelle Präsident der Vereinigten Staaten von Amerika ist Joe Biden.</p>

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

Hugging Face ist eine kostenlose Transformers-Python-Bibliothek, die mit PyTorch, TensorFlow und JAX kompatibel ist und Implementierungen von Modellen wie BERT, T5 usw. umfasst.

Hugging Face bietet auch den Hugging Face Hub, eine Plattform für die Bereitstellung von Code-Repositorys, maschinellen Lernalgorithmen, Daten 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 (GOOGL ), das Flan-T5-XXL-Modell, verwendet:

from langchain.llms import HuggingFaceHub

<p>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)</p>

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

Schritt 4: Grundlegende Prompt-Engineering

Zunächst werden wir ein einfaches Prompt generieren und sehen, wie das Modell 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')

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

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

Schritt 5: Erweiterte Prompt-Engineering

Während der obige Ansatz funktioniert, nutzt er nicht die volle Kraft der Prompt-Engineering. 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')

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

In diesem Code-Snippet modifizieren wir das 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 die Rolle eines Experten annimmt.

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

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

Zunächst stellen wir sicher, dass 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

Das Kernstück unseres Frage-Antwort-Systems ist die Fähigkeit, relevante akademische Artikel im Zusammenhang mit einem bestimmten Bereich, hier Natürliche Sprachverarbeitung (NLP), aus 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:

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

documents = []

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

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 unsere Quellen und LangChain einrichten:

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

Jetzt, da unser akademisches Frage-Antwort-System bereit ist, können wir es testen, indem wir eine Frage stellen:

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

Die Ausgabe wird die Antwort auf Ihre Frage sein, einschließlich der Quellen, aus denen die Informationen extrahiert wurden. Zum Beispiel:

<p>Die jüngsten Fortschritte in NLP umfassen die Entwicklung von Retriever-augmentierten Anweisungsfolge-Modellen und eines neuen Rechenframeworks zur Lösung von ACOPF-Problemen (Alternating Current Optimal Power Flow) mithilfe von Grafikprozessoren (GPUs).
QUELLEN: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Sie können leicht das Modell wechseln oder das System an Ihre Bedürfnisse anpassen. Zum Beispiel wechseln wir hier zu GPT-4, was uns eine viel bessere und detailliertere Antwort liefert.

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4", temperature=0))

<p>Die jüngsten Fortschritte in der Natürlichen Sprachverarbeitung (NLP) umfassen die Entwicklung von Retriever-augmentierten Anweisungsfolge-Modellen für Informationsabrufaufgaben wie Frage-Antwort-Systeme. Diese Modelle können an verschiedene Informationsdomänen und Aufgaben ohne zusätzliche Feinabstimmung angepasst werden. Allerdings haben sie oft Schwierigkeiten, sich an die bereitgestellten Kenntnisse zu halten, und können in ihren Antworten halluzinieren. Ein weiterer Fortschritt ist die Einführung eines Rechenframeworks zur Lösung von ACOPF-Problemen mithilfe von Grafikprozessoren (GPUs). Dieser Ansatz nutzt eine Single-Instruction, Multiple-Data (SIMD)-Abstraktion von nichtlinearen Programmen (NLP) und verwendet eine kondensierte Raum-Innerer-Punkt-Methode (IPM) mit einer Ungleichheitsrelaxationsstrategie. Diese Strategie ermöglicht die Faktorisierung der KKT-Matrix ohne numerische Schwenkbewegung, was zuvor die Parallelisierung des IPM-Algorithms behindert hat.
QUELLEN: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Ein Token in GPT-4 kann so kurz wie ein einzelnes Zeichen oder so lang wie ein Wort sein. Zum Beispiel kann GPT-4-32K bis zu 32.000 Token in einem Durchgang 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.

In dem Kontext unseres Frage-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) (META ) hilft dabei, die relevantesten Textteile in Bezug auf die Benutzeranfrage 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 Benutzeranfrage am ähnlichsten sind.

Es ist wichtig zu beachten, dass, auch wenn FAISS verwendet wird, die Notwendigkeit, den Text in kleinere Teile aufzuteilen, aufgrund der 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 sichergestellt 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) # Jetzt können wir 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))

<p>search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())</p>

<p>chain = load_qa_with_sources_chain(OpenAI(temperature=0))</p>

<p>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 leistungsstarkes Werkzeug, um die neueste akademische Literatur im Bereich NLP abzufragen.

Die jüngsten Fortschritte in NLP umfassen die Verwendung von Deep Neural Networks (DNNs) für automatische Textanalyse und NLP-Aufgaben wie Rechtschreibprüfung, Spracherkennung, Entitätsextraktion, Autorenerkennung, Frage-Antwort-Systeme 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 Übernahme in verschiedenen Bereichen beschleunigt, einschließlich Sprachübersetzung, Sentiment-Analyse und Informationsabruf. Prompt-Engineering ist ein leistungsstarkes Werkzeug, um das volle Potenzial dieser Modelle auszuschöpfen, und Langchain führt den Weg, um diese komplexe Aufgabe zu vereinfachen. Seine standardisierte Schnittstelle, flexible Prompt-Vorlagen, robuste Modell-Integration und die innovative Verwendung von Agenten und Ketten garantieren optimale Ergebnisse für die Leistung von LLMs.

Es ist jedoch wichtig, einige Tipps im Hinterkopf zu behalten. Wenn Sie Langchain verwenden, ist es entscheidend, 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. Außerdem ist es 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 entscheidend. Schließlich ist es wichtig, sich daran zu erinnern, dass die Verwendung dieser Modelle mit Kosten verbunden ist, da die Token-Verarbeitung direkt die Kosten der Interaktionen beeinflusst.

Wie in der Schritt-für-Schritt-Anleitung demonstriert, kann Langchain leistungsstarke Anwendungen wie das akademische Literatur-Frage-Antwort-System antreiben. Mit einer wachsenden Benutzergemeinschaft und zunehmender Bedeutung im Open-Source-Landschaft verspricht Langchain, ein entscheidendes Werkzeug zur Ausschöpfung des vollen Potenzials von LLMs wie GPT-4 zu sein.