Cum se implementează logica ReAct folosind un agent în LangChain?

„ Reacţiona ” este combinația dintre fazele Motiv și Acțiune pentru a îmbunătăți performanța modelului lingvistic ca „ Re ” se referă la rațiune și ” act ” la acțiune. O logică ReAct este adesea considerată cea mai optimizată pentru construirea de LLM-uri sau chatbot-uri pentru a înțelege și a genera text. Agentul este decidentul care decide ce acțiuni să efectueze și în ce ordine vor fi efectuate.

Pentru a afla procesul de implementare a logicii ReAct folosind un agent în LangChain, parcurgeți următorul ghid:

Pasul 1: Instalarea cadrelor

Mai întâi de toate, instalați LangChain pentru a începe procesul de implementare a logicii ReAct:

pip install langchain

Instalați modulul google-search-results pentru a obține dependențele pentru construirea agentului care poate obține rezultatele căutării de la google:

pip install openai google-search-results

După aceea, instalați modulele OpenAI care pot fi folosite pentru a încărca modelele de limbaj mari sau LLM-urile pentru a implementa logica ReAct:

pip install openai

După ce obțineți toate modulele necesare, pur și simplu configurați Mediul OpenAI pentru construirea LLM și Mediul SerpAPI pentru utilizarea agentului în model:

import tu

import getpass

tu . aproximativ [ „OPENAI_API_KEY” ] = getpass . getpass ( „Cheie API OpenAI:” )

tu . aproximativ [ „SERPAPI_API_KEY” ] = getpass . getpass ( „Cheia API Serpapi:” )

Pasul 2: Încărcarea modelului de limbă

Următorul pas este încărcarea modelelor de limbaj prin importul bibliotecilor necesare folosind cadrul LangChain:

din langchain. agenţi import load_tools

din langchain. agenţi import initialize_agent

din langchain. agenţi import AgentType

din langchain. llms import OpenAI

Utilizați metoda OpenAI() pentru a construi modelul de limbaj (llm) și apoi configurați instrumentele pentru agenți folosind SerpAPI:

llm = OpenAI ( temperatura = 0 )

unelte = load_tools ( [ 'serpapi' , 'llm-matematica' ] , llm = llm )

Metoda 1: Utilizarea limbajului de expresie LandChain

LCEL este procesul de integrare sau alcătuire a lanțurilor împreună în timp ce se construiește modelele de limbaj în LangChain. Începeți procesul instalând LangChainHub pentru a obține dependențele sale pentru construirea și utilizarea logicii ReAct cu agenți în LangChain:

pip install langchainhub

Importul bibliotecilor din LangChain precum ReActSingleInputOutputParser pentru a construi modelul care poate folosi modelul ReAct:

din langchain. unelte . face import render_text_description

din langchain. agenţi . analizoare_ieșire import ReActSingleInputOutputParser

din langchain. agenţi . format_scratchpad import format_log_to_str

din langchain import hub

Încărcați modelul de limbaj pentru a proiecta logica ReAct folosind metoda pull() și stocați-l în variabila prompt. Definiți câteva instrumente care pot fi utilizate pentru a implementa logica pe setul de date încărcat pentru a implementa lucrul acestuia cu un agent:

prompt = hub. Trage ( „hwchase17/react” )

prompt = prompt. parțial (

unelte = render_text_description ( unelte ) ,

nume_instrumente = ', ' . a te alatura ( [ t. Nume pentru t în unelte ] ) ,

)

Agent de constructii

Acum, configurați agentul și instrumentele acestuia integrându-l cu modelul de limbă încărcat în pasul 2 al acestui ghid:

llm_cu_stop = llm. lega ( Stop = [ ' \n Observare' ] )

Definiți o variabilă agent pentru a furniza argumentele și instrumentele pentru a configura agentul care explică funcționarea acestuia. Părțile configurate anterior, cum ar fi metoda llm_with_stop și ReActSingleInputOutputParser() sunt integrate cu agentul:

agent = {

'intrare' : lambda x: x [ 'intrare' ] ,

'agent_scratchpad' : lambda x: format_log_to_str ( X [ „pași_intermediari” ] )

} | prompt | llm_cu_stop | ReActSingleInputOutputParser ( )

Obțineți biblioteca AgentExecutor și configurați metoda acesteia folosind argumente precum agent, instrumente și verbose pentru a obține o ieșire mai lizibilă:

din langchain. agenţi import Agent Executor

agent_executor = Agent Executor ( agent = agent , unelte = unelte , verboroasă = Adevărat )

Invocați metoda agent_executor() cu interogarea șir ca intrare care va declanșa agentul să extragă rezultatul:

agent_executor. invoca ( { 'intrare' : „Cine este iubita lui Leo DiCaprio” } )

Ieșire

Următoarea captură de ecran arată că agentul a extras informațiile folosind logica ReAct și a generat textul în limbaj natural:

Metoda 2: Utilizarea ZeroShotReactAgent

Logica ReAct poate fi implementată și prin utilizarea unui alt agent, cum ar fi ZeroShotReactAgent, în timpul configurării variabilei agent_executor. După aceea, pur și simplu apelați variabila agent_executor cu întrebarea ca intrare pentru a invoca agentul:

agent_executor = initialize_agent ( unelte , llm , agent = AgentType. ZERO_SHOT_REACT_DESCRIPTION , verboroasă = Adevărat )

agent_executor. invoca ( { 'intrare' : „Care este vârsta iubitei lui Leo DiCaprio ridicată la puterea de 0,21” } )

Ieșire

Agentul a extras informațiile pe baza intrării solicitate la invocarea agentului_executor:

Metoda 3: Utilizarea modelelor de chat

Un alt proces care poate fi folosit pentru a implementa logica ReAct prin utilizarea modelelor de chat după importarea bibliotecii ChatOpenAI:

din langchain. chat_models import ChatOpenAI

Construiți modelul de chat folosind metoda ChatOpenAI() cu valoarea temperaturii egală cu 0, care poate controla aleatoritatea rezultatelor modelului:

chat_model = ChatOpenAI ( temperatura = 0 )

Încărcați modelul pe care utilizatorul poate implementa logica ReAct pentru a-l stoca în variabila prompt și configura instrumentele care vor fi utilizate în proces:

prompt = hub. Trage ( „hwchase17/react-json” )

prompt = prompt. parțial (

unelte = render_text_description ( unelte ) ,

nume_instrumente = ', ' . a te alatura ( [ t. Nume pentru t în unelte ] ) ,

)

Construirea agentului

Utilizați modelul de chat pentru a stoca observațiile sau mesajele recente atunci când modelul nu mai generează textul:

chat_model_with_stop = chat_model. lega ( Stop = [ ' \n Observare' ] )

Obțineți biblioteca ReActJsonSingleInputOutputParser pentru a implementa logica ReAct și a produce rezultatele în format JSON:

din langchain. agenţi . analizoare_ieșire import ReActJsonSingleInputOutputParser

Creați și configurați agentul folosind variabila și metoda chat_model pentru a produce rezultate apelând agentul:

agent = {

'intrare' : lambda x: x [ 'intrare' ] ,

'agent_scratchpad' : lambda x: format_log_to_str ( X [ „pași_intermediari” ] )

} | prompt | chat_model_cu_stop | ReActJsonSingleInputOutputParser ( )

Configurați agent_executor și rulați-l pentru a obține rezultatele pe baza interogării furnizate în variabila de intrare:

agent_executor = Agent Executor ( agent = agent , unelte = unelte , verboroasă = Adevărat )

agent_executor. invoca ( { 'intrare' : „Care este vârsta iubitei lui Leo DiCaprio ridicată la puterea de 0,21” } )

Ieșire

Agentul a extras rezultatul așa cum este afișat în următoarea captură de ecran:

Metoda 4: Utilizarea ChatZeroShotReactAgent

Modificarea valorii agentului poate fi folosită și pentru a implementa logica ReAct cu cadrul LangChain:

agent = initialize_agent ( unelte , chat_model , agent = AgentType. CHAT_ZERO_SHOT_REACT_DESCRIPTION , verboroasă = Adevărat )

agent. alerga ( „Care este vârsta iubitei lui Leo DiCaprio ridicată la puterea de 0,21” )

Ieșire

Structura de ieșire conține informații detaliate despre funcționarea agentului din jetoanele și modelul utilizat pentru extragerea informațiilor:

Acesta este totul despre procesul de implementare a logicii ReAct folosind un agent în LangChain.

Concluzie

Pentru a implementa logica ReAct cu un agent folosind cadrul LangChain, instalați module precum google-search-results pentru a configura agentul. După aceea, configurați mediul folosind acreditările OpenAI și SerpAPI din conturile lor pentru a începe să utilizați modelul. Logica ReAct poate fi implementată folosind modelele LCEL și chat cu mai mulți agenți oferite de modulul LangChain. Acest ghid a elaborat despre implementarea logicii ReAct folosind agentul din LangChain.

Cum se implementează logica ReAct folosind un agent în LangChain?

Schiță rapidă