Zero to Advanced Prompt Engineering mit Langchain in Python

Ein wichtiger Aspekt von Large Language Models (LLMs) ist die Anzahl der Parameter, die diese Modelle zum 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 in der Lage sind, verschiedene kreative Textformate zu generieren und offene und anspruchsvolle Fragen auf 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 das Verständnis natürlicher Sprache erfordern. Sie sind jedoch nicht ohne Einschränkungen, zu denen unter anderem veraltetes Wissen, die Unfähigkeit, mit externen Systemen zu interagieren, mangelndes Kontextverständnis und manchmal plausibel klingende, aber falsche oder unsinnige Antworten gehören.

Um diese Einschränkungen zu beseitigen, müssen LLMs mit externen Datenquellen und -funktionen integriert werden, was komplex sein kann und umfassende Programmier- und Datenverarbeitungsfähigkeiten erfordert. Dies trägt zusammen mit den Herausforderungen, KI-Konzepte und komplexe Algorithmen zu verstehen, zur Lernkurve bei, die mit der Entwicklung von Anwendungen mithilfe von LLMs verbunden ist.

Dennoch könnte die Integration von LLMs mit anderen Tools zur Bildung LLM-gestützter Anwendungen unsere digitale Landschaft neu definieren. Das Potenzial solcher Anwendungen ist enorm, einschließlich der Verbesserung von Effizienz und Produktivität, der Vereinfachung von Aufgaben, der Verbesserung der Entscheidungsfindung und der Bereitstellung personalisierter Erlebnisse.

In diesem Artikel werden wir uns eingehender mit diesen Themen befassen, die fortschrittlichen Techniken des Prompt Engineering mit Langchain erkunden und klare Erklärungen, praktische Beispiele und Schritt-für-Schritt-Anleitungen für deren Implementierung bieten.

Langchain, eine hochmoderne Bibliothek, bietet Komfort und Flexibilität beim Entwerfen, Implementieren und Optimieren von Prompts. Wir erläutern die Prinzipien und Praktiken des Prompt Engineering und zeigen Ihnen, wie Sie die leistungsstarken Funktionen von Langchain nutzen, um die Stärken von SOTA Generative AI-Modellen wie GPT-4 zu nutzen.

Eingabeaufforderungen verstehen

Bevor Sie sich mit den technischen Details des Prompt Engineering befassen, ist es wichtig, das Konzept der Prompts und ihre Bedeutung zu verstehen.

EIN 'Eingabeaufforderung' ist eine Folge von Token, die als Eingabe für ein Sprachmodell verwendet werden und dieses anweisen, eine bestimmte Art von Antwort zu generieren. Eingabeaufforderungen spielen eine entscheidende Rolle bei der Steuerung des Verhaltens eines Modells. Sie können sich auf die Qualität des generierten Textes auswirken und bei richtiger Gestaltung dazu beitragen, dass das Modell aufschlussreiche, genaue und kontextspezifische Ergebnisse liefert.

Prompt Engineering ist die Kunst und Wissenschaft, effektive Prompts zu entwickeln. Ziel ist es, die gewünschte Ausgabe aus einem Sprachmodell zu erhalten. Durch sorgfältige Auswahl und Strukturierung der Prompts kann das Modell präzisere und relevantere Antworten generieren. In der Praxis bedeutet dies, die Eingabephrasen zu optimieren, um den Trainings- und Strukturvorgaben des Modells gerecht zu werden.

Die Komplexität des Prompt-Engineerings reicht von einfachen Techniken, etwa der Versorgung des Modells mit relevanten Schlüsselwörtern, bis hin zu fortgeschritteneren Methoden, die den Entwurf komplexer, strukturierter Prompts beinhalten, die die internen Mechanismen des Modells zu ihrem Vorteil nutzen.

Langchain: Das am schnellsten wachsende Prompt-Tool

LangChain, gestartet im Oktober 2022 von Harrison Chase, ist zu einem der geworden am höchsten bewerteten Open-Source-Frameworks auf GitHub im Jahr 2023. Es bietet eine vereinfachte und standardisierte Schnittstelle zur Integration von Large Language Models (LLMs) in Anwendungen. Es bietet außerdem eine funktionsreiche Schnittstelle für schnelles Engineering, die es Entwicklern ermöglicht, mit verschiedenen Strategien zu experimentieren und ihre Ergebnisse zu bewerten. Durch den Einsatz von Langchain können Sie zeitnahe Engineering-Aufgaben effektiver und intuitiver ausführen.

LangFlow dient als Benutzeroberfläche für die Orchestrierung von LangChain-Komponenten in einem ausführbaren Flussdiagramm und ermöglicht so schnelles Prototyping und Experimentieren.

LangChain füllt eine entscheidende Lücke in der KI-Entwicklung für die Massen. Es ermöglicht eine Reihe von NLP-Anwendungen wie virtuelle Assistenten, Inhaltsgeneratoren, Frage-Antwort-Systeme und mehr, um eine Reihe realer Probleme zu lösen.

LangChain ist kein eigenständiges Modell oder Anbieter, sondern vereinfacht die Interaktion mit verschiedenen Modellen und erweitert die Funktionen von LLM-Anwendungen über die Einschränkungen eines einfachen API-Aufrufs hinaus.

Die Architektur von LangChain

Zu den Hauptkomponenten von LangChain gehören Modell-E/A, Eingabeaufforderungsvorlagen, Speicher, Agenten und Ketten.

Modell I/O

LangChain ermöglicht eine nahtlose Verbindung mit verschiedenen Sprachmodellen, indem es sie mit einer standardisierten Schnittstelle namens Model I/O umschließt. Dies ermöglicht einen mühelosen Modellwechsel zur Optimierung oder besseren Leistung. LangChain unterstützt verschiedene Sprachmodellanbieter, darunter OpenAI, Umarmendes Gesicht, Azure, Fireworksund vieles mehr.

Eingabeaufforderungsvorlagen

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

Ein einfaches Beispiel für eine Eingabeaufforderungsvorlage:

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="What are the recent advancements in the field of {subject}?")
print(prompt.format(subject="Natural Language Processing"))

Mit zunehmender Komplexität stoßen wir in LangChain auf ausgefeiltere Muster, wie zum Beispiel das Reason and Act (ReAct)-Muster. ReAct ist ein wichtiges Muster für die Aktionsausführung, bei dem der Agent einem geeigneten Tool eine Aufgabe zuweist, die Eingabe dafür anpasst und seine Ausgabe analysiert, um die Aufgabe zu erfüllen. Das folgende Python-Beispiel zeigt ein ReAct-Muster. Es zeigt, wie eine Eingabeaufforderung in LangChain strukturiert ist und eine Reihe von Gedanken und Aktionen verwendet, um ein Problem zu durchdenken und eine endgültige Antwort zu finden:

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}"""

Memory

Speicher ist ein wichtiges Konzept in LangChain, das es LLMs und Tools ermöglicht, Informationen über einen längeren Zeitraum hinweg zu speichern. Dieses zustandsorientierte Verhalten verbessert die Leistung von LangChain-Anwendungen, indem es frühere Antworten, Benutzerinteraktionen, den Zustand der Umgebung und die Ziele des Agenten speichert. Die Strategien ConversationBufferMemory und ConversationBufferWindowMemory helfen dabei, den Überblick über die vollständigen bzw. letzten Teile einer Konversation zu behalten. Für einen anspruchsvolleren Ansatz ermöglicht die Strategie ConversationKGMemory die Kodierung der Konversation als Wissensgraph, der in Eingabeaufforderungen zurückgeführt oder zur Vorhersage von Antworten verwendet werden kann, ohne das LLM aufzurufen.

Makler

Ein Agent interagiert mit der Welt, indem er Aktionen und Aufgaben ausführt. In LangChain kombinieren Agenten Tools und Ketten zur Aufgabenausführung. Es kann eine Verbindung zur Außenwelt für den Informationsabruf herstellen, um das LLM-Wissen zu erweitern und so deren inhärente Einschränkungen zu überwinden. Sie können je nach Situation entscheiden, Berechnungen an einen Taschenrechner oder einen Python-Interpreter zu übergeben.

Agenten sind mit Unterkomponenten ausgestattet:

• Zubehör: Dies sind funktionale Komponenten.
• Toolkits: Werkzeugsammlungen.
• Agenten-Ausführende: Dies ist der Ausführungsmechanismus, der die Auswahl zwischen Tools ermöglicht.

Agenten in LangChain folgen ebenfalls dem Zero-Shot-ReAct-Muster, bei dem die Entscheidung ausschließlich auf der Beschreibung des Tools basiert. Dieser Mechanismus kann durch Speicher erweitert werden, um den gesamten Gesprächsverlauf zu berücksichtigen. Mit ReAct können Sie einen LLM nicht bitten, Ihren Text automatisch zu vervollständigen, sondern ihn in einer Gedanken-/Handlungs-/Beobachtungsschleife zu einer Antwort auffordern.

Ketten

Ketten sind, wie der Begriff schon sagt, Abfolgen von Operationen, die es der LangChain-Bibliothek ermöglichen, Eingaben und Ausgaben von Sprachmodellen nahtlos zu verarbeiten. Diese integralen Komponenten von LangChain bestehen im Wesentlichen aus Links, bei denen es sich um andere Ketten oder Grundelemente wie Eingabeaufforderungen, Sprachmodelle oder Dienstprogramme handeln kann.

Stellen Sie sich eine Kette als Förderband in einer Fabrik vor. Jeder Schritt auf diesem Gürtel stellt eine bestimmte Operation dar, die darin bestehen kann, ein Sprachmodell aufzurufen, eine Python-Funktion auf einen Text anzuwenden oder sogar das Modell auf eine bestimmte Weise aufzufordern.

LangChain kategorisiert seine Ketten in drei Typen: Utility-Ketten, generische Ketten und kombinierte Dokumentenketten. Wir werden in unserer Diskussion auf Utility- und generische Ketten eingehen.

• Versorgungsketten sind speziell dafür konzipiert, präzise Antworten aus Sprachmodellen für eng definierte Aufgaben zu extrahieren. Sehen wir uns beispielsweise die LLMMathChain an. Diese Utility Chain ermöglicht Sprachmodellen mathematische Berechnungen. Sie akzeptiert eine Frage in natürlicher Sprache, und das Sprachmodell generiert daraufhin einen Python-Codeausschnitt, der dann ausgeführt wird, um die Antwort zu liefern.
• Generische KettenAndererseits dienen sie als Bausteine ​​für andere Ketten, können aber nicht direkt eigenständig verwendet werden. Diese Ketten, wie zum Beispiel die LLMChain, sind grundlegend und werden oft mit anderen Ketten kombiniert, um komplizierte Aufgaben zu erfüllen. Beispielsweise wird die LLMChain häufig zum Abfragen eines Sprachmodellobjekts verwendet, indem die Eingabe basierend auf einer bereitgestellten Eingabeaufforderungsvorlage formatiert und dann an das Sprachmodell übergeben wird.

Schrittweise Implementierung von Prompt Engineering mit Langchain

Wir begleiten Sie durch den Prozess der Implementierung von Prompt Engineering mit Langchain. Bevor Sie fortfahren, stellen Sie sicher, dass Sie die erforderliche Software und Pakete installiert haben.

Für die Einrichtung von LangChain können Sie beliebte Tools wie Docker, Conda, Pip und Poetry 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ört ein Dockerfile für Docker, a requirements.txt für Pip, a pyproject.toml für Poesie und a langchain_ai.yml Datei für Conda.

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

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

Pip verwaltet Umgebungen jedoch nicht selbst. Um verschiedene Umgebungen zu verwalten, verwenden wir das Tool virtualenv.

Im nächsten Abschnitt besprechen wir Modellintegrationen.

Schritt 1: Langchain einrichten

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: Langchain und andere notwendige Module importieren

Als nächstes importieren Sie Langchain zusammen mit anderen notwendigen Modulen. Hier importieren wir auch die Transformers-Bibliothek, die häufig in NLP-Aufgaben verwendet wird.

import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Schritt 3: Vorab trainiertes Modell laden

AI öffnen

OpenAI Modelle können bequem mit der LangChain-Bibliothek oder der OpenAI Python-Clientbibliothek verbunden werden. OpenAI bietet insbesondere eine Embedding-Klasse für Texteinbettungsmodelle. Zwei wichtige LLM-Modelle sind GPT-3.5 und GPT-4, die sich hauptsächlich in der Tokenlänge unterscheiden. Preise für jedes Modell finden Sie auf der OpenAI-Website. Es gibt zwar weitere anspruchsvolle Modelle wie GPT-4-32K die eine höhere Token-Akzeptanz haben, ist ihre Verfügbarkeit über die API nicht immer garantiert.

Für den Zugriff auf diese Modelle ist ein OpenAI-API-Schlüssel erforderlich. Dies kann durch die Erstellung eines Kontos auf der OpenAI-Plattform, die Einrichtung von Rechnungsinformationen und die Generierung eines neuen geheimen Schlüssels erfolgen.

import os
os.environ["OPENAI_API_KEY"] = 'your-openai-token'

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

Betrachten Sie ein LangChain-Skript, um die Interaktion mit den OpenAI-Modellen zu veranschaulichen:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# The LLM takes a prompt as an input and outputs a completion
prompt = "who is the president of the United States of America?"
completion = llm(prompt)

The current President of the United States of America is Joe Biden.

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

Gesicht umarmen

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

Hugging Face bietet außerdem den Hugging Face Hub, eine Plattform zum Hosten von Code-Repositorys, Modellen für maschinelles Lernen, Datensätzen und Webanwendungen.

Um Hugging Face als Anbieter für Ihre Modelle zu nutzen, benötigen Sie ein Konto und API-Schlüssel, die Sie auf der Website erhalten. Das Token kann in Ihrer Umgebung als HUGGINGFACEHUB_API_TOKEN bereitgestellt werden.

Betrachten Sie das folgende Python-Snippet, das ein von Google entwickeltes Open-Source-Modell, 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 which country is Tokyo?"
completion = llm(prompt)
print(completion)

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

Schritt 4: Grundlegendes Prompt-Engineering

Zunächst generieren wir eine einfache Eingabeaufforderung und sehen, wie das Modell reagiert.

prompt = 'Translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
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))

Im obigen Codeausschnitt stellen wir eine Aufforderung zur Übersetzung von englischem Text ins Französische bereit. Das Sprachmodell versucht dann, den angegebenen Text basierend auf der Eingabeaufforderung zu übersetzen.

Schritt 5: Erweitertes Prompt Engineering

Der oben beschriebene Ansatz funktioniert zwar gut, nutzt aber nicht alle Vorteile des Prompt Engineering. Wir wollen ihn durch die Einführung komplexerer Prompt-Strukturen verbessern.

prompt = 'As a highly proficient French translator, translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
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 Codeausschnitt ändern wir die Eingabeaufforderung, um darauf hinzuweisen, dass die Übersetzung von einem „sehr kompetenten Französisch-Übersetzer“ angefertigt wird. Die Änderung der Eingabeaufforderung kann zu verbesserten Übersetzungen führen, da das Modell nun die Persona eines Experten annimmt.

Aufbau eines Q&A-Systems für wissenschaftliche Literatur mit Langchain

Wir werden mit LangChain ein Frage- und Antwortsystem zur wissenschaftlichen Literatur erstellen, das Fragen zu kürzlich veröffentlichten wissenschaftlichen Arbeiten beantworten kann.

Um unsere Umgebung einzurichten, installieren wir zunächst die notwendigen Abhängigkeiten.

pip install langchain arxiv openai transformers faiss-cpu

Im Anschluss an die 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 Q&A-Systems ist die Möglichkeit, relevante wissenschaftliche Arbeiten zu einem bestimmten Fachgebiet abzurufen. Hier betrachten wir die Verarbeitung natürlicher Sprache (NLP) mithilfe der akademischen Datenbank arXiv. Um dies durchzuführen, definieren wir eine Funktion get_arxiv_data(max_results=10). Diese Funktion sammelt die neuesten NLP-Papierzusammenfassungen von arXiv und kapselt sie in LangChain-Dokumentobjekte, wobei die Zusammenfassung als Inhalt und die eindeutige Eintrags-ID als Quelle verwendet werden.

Wir verwenden die arXiv-API, um aktuelle Artikel zum Thema 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 konvertiert sie in LangChain-Dokumentobjekte. Wir verwenden die Zusammenfassung des Artikels und seine eindeutige Eintrags-ID (URL zum Artikel) als Inhalt bzw. Quelle.

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

Definieren wir unser Korpus und richten LangChain ein:

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

Da unser akademisches Q&A-System nun fertig ist, können wir es testen, indem wir eine Frage stellen:

print_answer("What are the recent advancements in NLP?")

Die Ausgabe ist die Antwort auf Ihre Frage unter Angabe der Quellen, aus denen die Informationen extrahiert wurden. Zum Beispiel:

Recent advancements in NLP include Retriever-augmented instruction-following models and a novel computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs).
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Sie können problemlos zwischen Modellen wechseln oder das System Ihren Anforderungen entsprechend anpassen. Hier wechseln wir beispielsweise zu GPT-4, was uns letztendlich 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))

Recent advancements in Natural Language Processing (NLP) include the development of retriever-augmented instruction-following models for information-seeking tasks such as question answering (QA). These models can be adapted to various information domains and tasks without additional fine-tuning. However, they often struggle to stick to the provided knowledge and may hallucinate in their responses. Another advancement is the introduction of a computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). This approach utilizes a single-instruction, multiple-data (SIMD) abstraction of nonlinear programs (NLP) and employs a condensed-space interior-point method (IPM) with an inequality relaxation strategy. This strategy allows for the factorization of the KKT matrix without numerical pivoting, which has previously hampered the parallelization of the IPM algorithm.
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Ein Token in GPT-4 kann ein Zeichen oder ein Wort lang sein. Beispielsweise 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 Kosten verbunden ist, die direkt proportional zur Anzahl der verarbeiteten Token sind, sei es Input oder Output.

Wenn im Rahmen unseres Q&A-Systems ein Teil der wissenschaftlichen Literatur die maximale Token-Grenze überschreitet, kann das System ihn nicht vollständig verarbeiten, was sich auf die Qualität und Vollständigkeit der Antworten auswirkt. Um dieses Problem zu umgehen, kann der Text in kleinere Teile zerlegt werden, die dem Token-Limit entsprechen.

FAISS (Facebook-KI-Ähnlichkeitssuche) hilft dabei, schnell die relevantesten Textblöcke im Zusammenhang mit der Benutzeranfrage zu finden. Es erstellt eine Vektordarstellung jedes Textblocks und verwendet diese Vektoren, um die Blöcke zu identifizieren und abzurufen, die der Vektordarstellung einer bestimmten Frage am ähnlichsten sind.

Es ist wichtig zu bedenken, dass selbst bei der Verwendung von Tools wie FAISS die Notwendigkeit, den Text aufgrund von Token-Beschränkungen in kleinere Abschnitte zu unterteilen, manchmal zu Kontextverlust führen kann, was die Qualität der Antworten beeinträchtigt. Daher sind eine sorgfältige Verwaltung und Optimierung der Token-Nutzung bei der Arbeit mit diesen großen Sprachmodellen von entscheidender Bedeutung.

 
pip install faiss-cpu langchain CharacterTextSplitter

Nachdem Sie sichergestellt haben, dass die oben genannten Bibliotheken installiert sind, führen Sie 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) # We can now use feed more data
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 der Fertigstellung des Codes verfügen wir nun über ein leistungsstarkes Tool zum Abfragen der neuesten akademischen Literatur im Bereich NLP.

 
Recent advancements in NLP include the use of deep neural networks (DNNs) for automatic text analysis and natural language processing (NLP) tasks such as spell checking, language detection, entity extraction, author detection, question answering, and other tasks. 
SOURCES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1 

Fazit

Die Integration von Large Language Models (LLMs) in Anwendungen hat die Akzeptanz in verschiedenen Bereichen beschleunigt, darunter Sprachübersetzung, Sentimentanalyse und Informationsabruf. Prompt Engineering ist ein leistungsstarkes Tool, um das Potenzial dieser Modelle zu maximieren, und Langchain ist führend bei der Vereinfachung dieser komplexen Aufgabe. Seine standardisierte Schnittstelle, flexible Prompt-Vorlagen, robuste Modellintegration und der innovative Einsatz von Agenten und Ketten sorgen für optimale Ergebnisse bei der Leistung von LLMs.

Trotz dieser Fortschritte gibt es einige Tipps zu beachten. Bei der Verwendung von Langchain ist es wichtig zu verstehen, dass die Qualität der Ausgabe stark von der Formulierung der Eingabeaufforderung abhängt. Das Experimentieren mit verschiedenen Eingabeaufforderungsstilen und -strukturen kann zu besseren Ergebnissen führen. Bedenken Sie außerdem, dass Langchain zwar eine Vielzahl von Sprachmodellen unterstützt, jedes jedoch seine Stärken und Schwächen hat. Die Wahl des richtigen Modells für Ihre spezifische Aufgabe ist entscheidend. Schließlich ist es wichtig zu bedenken, dass die Verwendung dieser Modelle mit Kosten verbunden ist, da die Token-Verarbeitung die Interaktionskosten direkt beeinflusst.

Wie in der Schritt-für-Schritt-Anleitung gezeigt, kann Langchain robuste Anwendungen wie das Q&A-System für akademische Literatur unterstützen. Mit einer wachsenden Benutzergemeinschaft und zunehmender Bedeutung in der Open-Source-Landschaft verspricht Langchain, ein entscheidendes Werkzeug zu sein, um das volle Potenzial von LLMs wie GPT-4 auszuschöpfen.