Wie implementiert man die ReAct-Logik mithilfe eines Agenten in LangChain?

Der ' Reagieren „ist die Kombination der Reason- und Action-Phasen zur Verbesserung der Leistung des Sprachmodells als „ Re „bezieht sich auf Vernunft und“ Akt ” zum Handeln. Eine ReAct-Logik gilt oft als die am besten optimierte Logik für den Aufbau von LLMs oder Chatbots zum Verstehen und Generieren von Text. Der Agent ist der Entscheidungsträger, der entscheidet, welche Aktionen ausgeführt werden sollen und in welcher Reihenfolge sie ausgeführt werden.

Um den Prozess der Implementierung der ReAct-Logik mithilfe eines Agenten in LangChain zu erlernen, gehen Sie einfach die folgende Anleitung durch:

Schritt 1: Frameworks installieren

Installieren Sie zunächst LangChain, um mit der Implementierung der ReAct-Logik zu beginnen:

pip langchain installieren

Installieren Sie das Modul „google-search-results“, um die Abhängigkeiten zum Erstellen des Agenten abzurufen, der die Suchergebnisse von Google abrufen kann:

pip install openai google-search-results

Installieren Sie anschließend die OpenAI-Module, mit denen Sie die Large Language Models oder LLMs laden können, um die ReAct-Logik zu implementieren:

pip openai installieren

Nachdem Sie alle erforderlichen Module erhalten haben, richten Sie einfach die ein OpenAI-Umgebung zum Aufbau von LLM und SerpAPI-Umgebung zur Verwendung des Agenten im Modell:

importieren Du

importieren getpass

Du . etwa [ „OPENAI_API_KEY“ ] = getpass . getpass ( „OpenAI-API-Schlüssel:“ )

Du . etwa [ „SERPAPI_API_KEY“ ] = getpass . getpass ( „Serpapi-API-Schlüssel:“ )

Schritt 2: Sprachmodell laden

Der nächste Schritt ist das Laden der Sprachmodelle durch den Import der erforderlichen Bibliotheken mithilfe des LangChain-Frameworks:

aus langchain. Agenten importieren Load_tools

aus langchain. Agenten importieren initialize_agent

aus langchain. Agenten importieren AgentType

aus langchain. lms importieren OpenAI

Verwenden Sie die OpenAI()-Methode, um das Sprachmodell (llm) zu erstellen, und konfigurieren Sie dann die Tools für die Agenten mithilfe von SerpAPI:

llm = OpenAI ( Temperatur = 0 )

Werkzeuge = Load_tools ( [ „Serpapi“ , „llm-math“ ] , llm = llm )

Methode 1: Verwendung der LandChain Expression Language

LCEL ist der Prozess der Integration oder Zusammenstellung von Ketten beim Aufbau der Sprachmodelle in LangChain. Starten Sie den Prozess, indem Sie den LangChainHub installieren, um seine Abhängigkeiten zum Erstellen und Verwenden der ReAct-Logik mit Agenten in LangChain zu erhalten:

pip install langchainhub

Importieren der Bibliotheken aus LangChain wie ReActSingleInputOutputParser, um das Modell zu erstellen, das das ReAct-Modell verwenden kann:

aus langchain. Werkzeuge . machen importieren render_text_description

aus langchain. Agenten . Ausgabeparser importieren ReActSingleInputOutputParser

aus langchain. Agenten . format_scratchpad importieren format_log_to_str

aus langchain importieren Nabe

Laden Sie das Sprachmodell, um die ReAct-Logik mithilfe der pull()-Methode zu entwerfen, und speichern Sie es in der Eingabeaufforderungsvariablen. Definieren Sie einige Tools, die zum Implementieren der Logik im geladenen Datensatz verwendet werden können, um dessen Zusammenarbeit mit einem Agenten zu implementieren:

prompt = Nabe. ziehen ( „hwchase17/reagieren“ )

prompt = prompt. teilweise (

Werkzeuge = render_text_description ( Werkzeuge ) ,

Werkzeugnamen = ',' . verbinden ( [ T. Name für T In Werkzeuge ] ) ,

)

Baumakler

Konfigurieren Sie nun den Agenten und seine Tools, indem Sie ihn in das in Schritt 2 dieser Anleitung geladene Sprachmodell integrieren:

llm_with_stop = llm. binden ( stoppen = [ ' \N Überwachung' ] )

Definieren Sie eine Agentenvariable, um die Argumente und Tools zum Konfigurieren des Agenten bereitzustellen, die seine Funktionsweise erläutern. Die zuvor konfigurierten Teile wie llm_with_stop und die Methode ReActSingleInputOutputParser() werden in den Agenten integriert:

Agent = {

'Eingang' : Lambda x: x [ 'Eingang' ] ,

„agent_scratchpad“ : Lambda x: format_log_to_str ( X [ 'intermediate_steps' ] )

} | Eingabeaufforderung | llm_with_stop | ReActSingleInputOutputParser ( )

Rufen Sie die AgentExecutor-Bibliothek ab und konfigurieren Sie ihre Methode mit Argumenten wie Agent, Tools und Verbose, um eine besser lesbare Ausgabe zu erhalten:

aus langchain. Agenten importieren AgentExecutor

agent_executor = AgentExecutor ( Agent = Agent , Werkzeuge = Werkzeuge , ausführlich = WAHR )

Rufen Sie die Methode agent_executor() mit der Zeichenfolgenabfrage als Eingabe auf, die den Agenten dazu veranlasst, die Ausgabe zu extrahieren:

agent_executor. aufrufen ( { 'Eingang' : „Wer ist Leo DiCaprios Freundin“ } )

Ausgabe

Der folgende Screenshot zeigt, dass der Agent die Informationen mithilfe der ReAct-Logik extrahiert und den Text in natürlicher Sprache generiert hat:

Methode 2: Verwendung von ZeroShotReactAgent

Die ReAct-Logik kann auch implementiert werden, indem bei der Konfiguration der Variable agent_executor ein anderer Agent wie ZeroShotReactAgent verwendet wird. Rufen Sie danach einfach die Variable agent_executor mit der Frage als Eingabe auf, um den Agenten aufzurufen:

agent_executor = initialize_agent ( Werkzeuge , llm , Agent = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ausführlich = WAHR )

agent_executor. aufrufen ( { 'Eingang' : „Wie alt ist Leo DiCaprios Freundin, hochgerechnet 0,21?“ } )

Ausgabe

Der Agent hat die Informationen basierend auf der beim Aufruf des agent_executor angeforderten Eingabe extrahiert:

Methode 3: Chat-Modelle verwenden

Ein weiterer Prozess, mit dem die ReAct-Logik mithilfe der Chat-Modelle nach dem Import der ChatOpenAI-Bibliothek implementiert werden kann:

aus langchain. chat_models importieren ChatOpenAI

Erstellen Sie das Chat-Modell mit der Methode ChatOpenAI() mit einem Temperaturwert von 0, der die Zufälligkeit in den Ergebnissen des Modells steuern kann:

chat_model = ChatOpenAI ( Temperatur = 0 )

Laden Sie das Modell, auf dem der Benutzer die ReAct-Logik implementieren kann, um es in der Eingabeaufforderungsvariablen zu speichern und die im Prozess zu verwendenden Tools zu konfigurieren:

prompt = Nabe. ziehen ( „hwchase17/react-json“ )

prompt = prompt. teilweise (

Werkzeuge = render_text_description ( Werkzeuge ) ,

Werkzeugnamen = ',' . verbinden ( [ T. Name für T In Werkzeuge ] ) ,

)

Aufbau des Agenten

Verwenden Sie das Chat-Modell, um die Beobachtungen oder aktuellen Nachrichten zu speichern, wenn das Modell aufhört, den Text zu generieren:

chat_model_with_stop = chat_model. binden ( stoppen = [ ' \N Überwachung' ] )

Holen Sie sich die ReActJsonSingleInputOutputParser-Bibliothek, um die ReAct-Logik zu implementieren und die Ergebnisse im JSON-Format zu erzeugen:

aus langchain. Agenten . Ausgabeparser importieren ReActJsonSingleInputOutputParser

Erstellen und konfigurieren Sie den Agenten mithilfe der Variablen und Methoden chat_model, um durch Aufrufen des Agenten Ergebnisse zu erzielen:

Agent = {

'Eingang' : Lambda x: x [ 'Eingang' ] ,

„agent_scratchpad“ : Lambda x: format_log_to_str ( X [ 'intermediate_steps' ] )

} | Eingabeaufforderung | chat_model_with_stop | ReActJsonSingleInputOutputParser ( )

Konfigurieren Sie den agent_executor und führen Sie ihn aus, um die Ergebnisse basierend auf der in der Eingabevariablen bereitgestellten Abfrage zu erhalten:

agent_executor = AgentExecutor ( Agent = Agent , Werkzeuge = Werkzeuge , ausführlich = WAHR )

agent_executor. aufrufen ( { 'Eingang' : „Wie alt ist Leo DiCaprios Freundin, hochgerechnet 0,21?“ } )

Ausgabe

Der Agent hat die Ausgabe extrahiert, wie im folgenden Screenshot dargestellt:

Methode 4: Verwenden von ChatZeroShotReactAgent

Das Ändern des Werts des Agenten kann auch zur Implementierung der ReAct-Logik mit dem LangChain-Framework verwendet werden:

Agent = initialize_agent ( Werkzeuge , chat_model , Agent = AgentType. CHAT_ZERO_SHOT_REACT_DESCRIPTION , ausführlich = WAHR )

Agent. laufen ( „Wie alt ist Leo DiCaprios Freundin, hochgerechnet 0,21?“ )

Ausgabe

Die Ausgabestruktur enthält detaillierte Informationen über die Funktionsweise des Agenten aus den Token und dem Modell, die zum Extrahieren der Informationen verwendet werden:

Dabei geht es um den Prozess der Implementierung der ReAct-Logik mithilfe eines Agenten in LangChain.

Abschluss

Um die ReAct-Logik mit einem Agenten mithilfe des LangChain-Frameworks zu implementieren, installieren Sie Module wie google-search-results, um den Agenten zu konfigurieren. Anschließend richten Sie die Umgebung mit den OpenAI- und SerpAPI-Anmeldeinformationen ihrer Konten ein, um mit der Verwendung des Modells zu beginnen. Die ReAct-Logik kann mithilfe der vom LangChain-Modul angebotenen LCEL- und Chat-Modelle mit mehreren Agenten implementiert werden. In diesem Leitfaden wird die Implementierung der ReAct-Logik mithilfe des Agenten in LangChain erläutert.

Wie implementiert man die ReAct-Logik mithilfe eines Agenten in LangChain?

Kurzer Überblick