Einleitung

Generative KI wird derzeit weltweit in großem Umfang eingesetzt. Die Fähigkeit der Large Language Models, den bereitgestellten Text zu verstehen und darauf basierend einen Text zu generieren, hat zu zahlreichen Anwendungen von Chatbots bis hin zu Textanalysatoren geführt. Aber oft generieren diese großen Sprachmodelle Text so, wie er ist, und zwar auf unstrukturierte Weise. Manchmal möchten wir, dass die von den LLMs generierte Ausgabe in einem Strukturformat vorliegt, beispielsweise einem JSON-Format (JavaScript Object Notation). Nehmen wir an, wir analysieren einen Social-Media-Beitrag mit LLM, und wir benötigen die von LLM im Code selbst generierte Ausgabe als JSON/Python-Variable, um eine andere Aufgabe auszuführen. Mit Prompt Engineering ist dies zwar möglich, aber es erfordert viel Zeit, an den Eingabeaufforderungen herumzubasteln. Um dieses Problem zu lösen, hat LangChain Output Parses eingeführt, mit denen bei der Konvertierung des LLM-Ausgabespeichers in ein strukturiertes Format gearbeitet werden kann.

Lernziele

• Interpretieren der von großen Sprachmodellen generierten Ausgabe
• Erstellen benutzerdefinierter Datenstrukturen mit Pydantic
• Die Bedeutung von Eingabeaufforderungsvorlagen verstehen und eine Formatierung für die Ausgabe von LLM erstellen
• Erfahren Sie, wie Sie mit LangChain Formatanweisungen für die LLM-Ausgabe erstellen
• Sehen Sie, wie wir JSON-Daten in ein Pydantic-Objekt analysieren können

Dieser Artikel wurde als Teil des veröffentlicht Data Science-Blogathon.

Was ist LangChain und Output Parsing?

LangChain ist eine Python-Bibliothek, mit der Sie innerhalb kürzester Zeit Anwendungen mit großen Sprachmodellen erstellen können. Es unterstützt eine Vielzahl von Modellen, darunter OpenAI GPT LLMs, Googles PaLMund sogar die im Hugging Face verfügbaren Open-Source-Modelle wie Falcon, Llama und viele mehr. Mit LangChain ist das Anpassen von Eingabeaufforderungen an die großen Sprachmodelle ein Kinderspiel und es verfügt außerdem über einen sofort einsatzbereiten Vektorspeicher, der die Einbettungen von Ein- und Ausgaben speichern kann. Damit lassen sich Anwendungen erstellen, die beliebige Dokumente innerhalb von Minuten abfragen können.

LangChain ermöglicht großen Sprachmodellen den Zugriff auf Informationen aus dem Internet über Agenten. Es bietet auch Ausgabeparser, die es uns ermöglichen, die Daten aus der von den Large Language Models generierten Ausgabe zu strukturieren. LangChain verfügt über verschiedene Ausgabeparser wie Listenparser, Datetime-Parser, Enum-Parser usw. In diesem Artikel werfen wir einen Blick auf den JSON-Parser, der es uns ermöglicht, die von den LLMs generierte Ausgabe in ein JSON-Format zu analysieren. Unten können wir einen typischen Ablauf beobachten, wie eine LLM-Ausgabe in ein Pydantic-Objekt geparst wird und so gebrauchsfertige Daten in Python-Variablen erstellt werden

Erste Schritte – Einrichten des Modells

In diesem Abschnitt richten wir das Modell mit LangChain ein. Wir werden in diesem Artikel PaLM als unser großes Sprachmodell verwenden. Wir werden Google Colab für unsere Umgebung verwenden. Sie können PaLM durch jedes andere große Sprachmodell ersetzen. Zunächst importieren wir die benötigten Module.

!pip install google-generativeai langchain

• Dadurch werden die LangChain-Bibliothek und die google-generativeai-Bibliothek für die Arbeit mit dem PaLM-Modell heruntergeladen.
• Die Langchain-Bibliothek ist erforderlich, um benutzerdefinierte Eingabeaufforderungen zu erstellen und die von den großen Sprachmodellen generierte Ausgabe zu analysieren
• Die google-generativeai-Bibliothek ermöglicht uns die Interaktion mit dem PaLM-Modell von Google.

PaLM-API-Schlüssel

Um mit PaLM arbeiten zu können, benötigen wir einen API-Schlüssel, den wir erhalten, indem wir uns auf der MakerSuite-Website anmelden. Als Nächstes importieren wir alle erforderlichen Bibliotheken und übergeben den API-Schlüssel, um das PaLM-Modell zu instanziieren.

import os
import google.generativeai as palm
from langchain.embeddings import GooglePalmEmbeddings
from langchain.llms import GooglePalm os.environ['GOOGLE_API_KEY']= 'YOUR API KEY'
palm.configure(api_key=os.environ['GOOGLE_API_KEY']) llm = GooglePalm()
llm.temperature = 0.1 prompts = ["Name 5 planets and line about them"]
llm_result = llm._generate(prompts)
print(llm_result.generations[0][0].text)

• Hier haben wir zunächst eine Instanz des Google PaLM (Pathways Language Model) erstellt und diese der Variablen zugewiesen llm
• Im nächsten Schritt legen wir fest Temperatur unseres Modells auf 0.1 und setzen ihn niedrig, weil wir nicht wollen, dass das Modell halluziniert
• Dann haben wir einen Prompt als Liste erstellt und ihn an die Variable übergeben Eingabeaufforderungen
• Um die Eingabeaufforderung an PaLM zu übergeben, rufen wir auf ._generieren() Methode und übergeben Sie dann die Prompt-Liste an sie und die Ergebnisse werden in der Variablen gespeichert llm_result
• Abschließend drucken wir das Ergebnis im letzten Schritt aus, indem wir den aufrufen .Generationen und Konvertieren in Text durch Aufrufen von .text Methode

Die Ausgabe für diese Eingabeaufforderung ist unten zu sehen

Wir können sehen, dass das Large Language Model eine faire Ausgabe generiert hat und das LLM auch versucht hat, ihm durch das Hinzufügen einiger Zeilen eine gewisse Struktur zu verleihen. Was aber, wenn ich die Informationen für jedes Modell in einer Variablen speichern möchte? Was ist, wenn ich den Planetennamen, die Umlaufzeit und die Entfernung von der Sonne separat in einer Variablen speichern möchte? Um dies zu erreichen, kann nicht direkt mit der vom Modell generierten Ausgabe gearbeitet werden. Daraus ergibt sich die Notwendigkeit von Output Parses.

Erstellen eines Pydantic-Ausgabeparsers und einer Eingabeaufforderungsvorlage

In diesem Abschnitt wird der pydantische Ausgabeparser von Langchain besprochen. Im vorherigen Beispiel erfolgte die Ausgabe in einem unstrukturierten Format. Sehen Sie sich an, wie wir die vom Large Language Model generierten Informationen in einem strukturierten Format speichern können.

Code-Implementierung

Schauen wir uns zunächst den folgenden Code an:

from pydantic import BaseModel, Field, validator
from langchain.output_parsers import PydanticOutputParser class PlanetData(BaseModel): planet: str = Field(description="This is the name of the planet") orbital_period: float = Field(description="This is the orbital period in the number of earth days") distance_from_sun: float = Field(description="This is a float indicating distance from sun in million kilometers") interesting_fact: str = Field(description="This is about an interesting fact of the planet")

• Hier importieren wir das Pydantic-Paket, um eine Datenstruktur zu erstellen. Und in dieser Datenstruktur speichern wir die Ausgabe, indem wir die Ausgabe vom LLM analysieren.
• Hier haben wir mit Pydantic eine Datenstruktur namens erstellt PlanetData das die folgenden Daten speichert
• Planet: Dies ist der Name des Planeten, den wir dem Modell als Eingabe geben werden
• Umlaufdauer: Dies ist ein Float-Wert, der die Umlaufzeit in Erdentagen für einen bestimmten Planeten enthält.
• Entfernung von der Sonne: Dies ist ein Float, der die Entfernung eines Planeten zur Sonne angibt
• Interessante Tatsache: Dies ist eine Zeichenfolge, die eine interessante Tatsache über den gefragten Planeten enthält

Jetzt wollen wir das Large Language Model nach Informationen über einen Planeten abfragen und alle diese Daten in der PlanetData-Datenstruktur speichern, indem wir die LLM-Ausgabe analysieren. Um eine LLM-Ausgabe in eine Pydantic-Datenstruktur zu analysieren, bietet LangChain einen Parser namens PydanticOutputParser an. An diesen Parser übergeben wir die PlanetData-Klasse, die wie folgt definiert werden kann:

planet_parser = PydanticOutputParser(pydantic_object=PlanetData)

Wir speichern den Parser in einer Variablen mit dem Namen planet_parser. Das Parser-Objekt verfügt über eine Methode namens get_format_instructions() Dadurch wird dem LLM mitgeteilt, wie die Ausgabe generiert werden soll. Versuchen wir es auszudrucken

from pprint import pp
pp(planet_parser.get_format_instructions())

Oben sehen wir, dass die Formatanweisungen Informationen zum Formatieren der vom LLM generierten Ausgabe enthalten. Es weist den LLM an, die Daten in einem JSON-Schema auszugeben, damit dieser JSON in die Pydantic-Datenstruktur geparst werden kann. Es enthält auch ein Beispiel für ein Ausgabeschema. Als Nächstes erstellen wir eine Eingabeaufforderungsvorlage.

Eingabeaufforderungsvorlage

from langchain import PromptTemplate, LLMChain template_string = """You are an expert when it comes to answering questions about planets You will be given a planet name and you will output the name of the planet, it's orbital period in days Also it's distance from sun in million kilometers and an interesting fact ```{planet_name}``` {format_instructions} """ planet_prompt = PromptTemplate( template=template_string, input_variables=["planet_name"], partial_variables={"format_instructions": planet_parser
.get_format_instructions()}
)

• In unserer Eingabeaufforderungsvorlage sagen wir, dass wir als Eingabe einen Planetennamen angeben und das LLM eine Ausgabe generieren muss, die Informationen wie Umlaufperiode, Entfernung von der Sonne und eine interessante Tatsache über den Planeten enthält
• Dann weisen wir diese Vorlage dem zu PromptTemplate() und geben Sie dann den Namen der Eingabevariablen an Eingabe_Variablen Parameter, in unserem Fall ist es der Planetenname
• Wir geben auch In-the-Format-Anweisungen, die wir zuvor gesehen haben, die dem LLM sagen, wie die Ausgabe in einem JSON-Format generiert werden soll

Versuchen wir, einen Planetennamen einzugeben und zu beobachten, wie die Eingabeaufforderung aussieht, bevor sie an das Large Language Model gesendet wird

input_prompt = planet_prompt.format_prompt(planet_name='mercury')
pp(input_prompt.to_string())

In der Ausgabe sehen wir, dass die von uns definierte Vorlage zuerst mit der Eingabe „Mercury“ erscheint. Darauf folgen die Formatierungsanweisungen. Diese Formatanweisungen enthalten die Anweisungen, die der LLM zum Generieren von JSON-Daten verwenden kann.

Testen des großen Sprachmodells

In diesem Abschnitt senden wir unsere Eingaben an das LLM und beobachten die generierten Daten. Im vorherigen Abschnitt sehen Sie, wie unsere Eingabezeichenfolge aussehen wird, wenn sie an das LLM gesendet wird.

input_prompt = planet_prompt.format_prompt(planet_name='mercury')
output = llm(input_prompt.to_string())
pp(output)

Wir können die vom Large Language Model generierte Ausgabe sehen. Die Ausgabe wird tatsächlich in einem JSON-Format generiert. Die JSON-Daten enthalten alle Schlüssel, die wir in unserer PlanetData-Datenstruktur definiert haben. Und jeder Schlüssel hat einen Wert, den wir von ihm erwarten.

Jetzt müssen wir diese JSON-Daten in die von uns erstellte Datenstruktur analysieren. Dies kann einfach mit dem PydanticOutputParser durchgeführt werden, den wir zuvor definiert haben. Schauen wir uns diesen Code an:

parsed_output = planet_parser.parse(output)
print("Planet: ",parsed_output.planet)
print("Orbital period: ",parsed_output.orbital_period)
print("Distance From the Sun(in Million KM): ",parsed_output.distance_from_sun)
print("Interesting Fact: ",parsed_output.interesting_fact)

Wenn Sie die parse()-Methode für den planet_parser aufrufen, wird die Ausgabe erfasst, analysiert und in ein Pydantic-Objekt konvertiert, in unserem Fall ein Objekt von PlanetData. Die Ausgabe, also das vom Large Language Model generierte JSON, wird in die PlannetData-Datenstruktur geparst und wir können nun von dort aus auf die einzelnen Daten zugreifen. Die Ausgabe für das Obige wird sein

Wir sehen, dass die Schlüssel-Wert-Paare aus den JSON-Daten korrekt in die Pydantic-Daten geparst wurden. Versuchen wir es mit einem anderen Planeten und beobachten die Ausgabe

input_prompt = planet_prompt.format_prompt(planet_name='venus')
output = llm(input_prompt.to_string()) parsed_output = planet_parser.parse(output)
print("Planet: ",parsed_output.planet)
print("Orbital period: ",parsed_output.orbital_period)
print("Distance From the Sun: ",parsed_output.distance_from_sun)
print("Interesting Fact: ",parsed_output.interesting_fact)

Wir sehen, dass das LLM für die Eingabe „Venus“ einen JSON als Ausgabe generieren konnte und dieser erfolgreich in Pydantic Data geparst wurde. Auf diese Weise können wir durch Ausgabeparsing die von den großen Sprachmodellen generierten Informationen direkt nutzen

Mögliche Anwendungen und Anwendungsfälle

In diesem Abschnitt werden wir einige potenzielle reale Anwendungen/Anwendungsfälle durchgehen, in denen wir diese Ausgabe-Parsing-Techniken einsetzen können. Verwenden Sie Parsing bei der Extraktion/nach der Extraktion. Das heißt, wenn wir Daten jeglicher Art extrahieren, möchten wir sie analysieren, damit die extrahierten Informationen von anderen Anwendungen genutzt werden können. Einige der Anwendungen umfassen:

• Extraktion und Analyse von Produktbeschwerden: Wenn eine neue Marke auf den Markt kommt und ihre neuen Produkte auf den Markt bringt, möchte sie zunächst die Leistung des Produkts überprüfen. Eine der besten Möglichkeiten, dies zu bewerten, besteht darin, Social-Media-Beiträge von Verbrauchern zu analysieren, die diese Produkte verwenden. Ausgabeparser und LLMs ermöglichen die Extraktion von Informationen wie Marken- und Produktnamen und sogar Beschwerden aus den Social-Media-Beiträgen eines Verbrauchers. Diese großen Sprachmodelle speichern diese Daten durch Ausgabeanalyse in Pythonic-Variablen, sodass Sie sie für Datenvisualisierungen verwenden können.
• Kundenservice Bei der Erstellung von Chatbots mit LLMs für den Kundensupport wird es eine wichtige Aufgabe sein, die Informationen aus dem Chatverlauf des Kunden zu extrahieren. Diese Informationen enthalten wichtige Details, beispielsweise welche Probleme die Verbraucher in Bezug auf das Produkt/die Dienstleistung haben. Sie können diese Details ganz einfach mit LangChain-Ausgabeparsern extrahieren, anstatt benutzerdefinierten Code zum Extrahieren dieser Informationen zu erstellen
• Informationen zur Stellenausschreibung: Bei der Entwicklung von Jobsuchplattformen wie Indeed, LinkedIn usw. können wir LLMs verwenden, um Details aus Stellenausschreibungen zu extrahieren, darunter Berufsbezeichnungen, Firmennamen, jahrelange Erfahrung und Stellenbeschreibungen. Beim Parsen der Ausgabe können diese Informationen als strukturierte JSON-Daten für Jobabgleiche und Empfehlungen gespeichert werden. Durch das Parsen dieser Informationen aus der LLM-Ausgabe direkt über die LangChain-Ausgabeparser wird viel redundanter Code entfernt, der für die Durchführung dieses separaten Parsing-Vorgangs erforderlich ist.

Zusammenfassung

Große Sprachmodelle sind großartig, da sie aufgrund ihrer außergewöhnlichen Textgenerierungsfähigkeiten buchstäblich in jeden Anwendungsfall passen. Meistens sind sie jedoch unzureichend, wenn es darum geht, die generierte Ausgabe tatsächlich zu nutzen, da wir viel Zeit mit der Analyse der Ausgabe verbringen müssen. In diesem Artikel haben wir uns mit diesem Problem befasst und wie wir es mithilfe der Ausgabeparser von LangChain lösen können, insbesondere des JSON-Parsers, der die von LLM generierten JSON-Daten analysieren und in ein Pydantic-Objekt konvertieren kann.

Key Take Away

Zu den wichtigsten Erkenntnissen aus diesem Artikel gehören:

• LangChain ist eine Python-Bibliothek, mit der Anwendungen mit den vorhandenen großen Sprachmodellen erstellt werden können.
• LangChain bietet Ausgabeparser, mit denen wir die von den großen Sprachmodellen generierte Ausgabe analysieren können.
• Mit Pydantic können wir benutzerdefinierte Datenstrukturen definieren, die beim Parsen der Ausgabe der LLMs verwendet werden können.
• Neben dem Pydantic JSON-Parser bietet LangChain auch verschiedene Ausgabeparser wie den Listenparser, den Datetime-Parser, den Enum-Parser usw.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Verbunden

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• Quelle: https://www.analyticsvidhya.com/blog/2023/11/structured-llm-output-storage-and-parsing-in-python/