Paano Ipapatupad ang ReAct Logic Gamit ang isang Ahente sa LangChain?

Paano Ipapatupad Ang React Logic Gamit Ang Isang Ahente Sa Langchain



Ang LangChain ay ang balangkas para sa pagbuo ng mga modelo ng wika at mga chatbot na makakaunawa at makabuo ng teksto sa wika ng tao. Ang pagganap ng modelo ay batay sa pag-unawa sa wika at sa mga kumplikado nito sa panahon ng yugto ng pagsasanay ng proseso. Ang susunod na yugto ay ang pagbuo ng data o teksto sa natural na wika na madaling mabasa at maunawaan. Ang mga yugtong ito ay tinutukoy bilang ' Pangangatwiran 'at' Pag-arte ” ayon sa pagkakabanggit sa domain ng Natural Language Processing.

Mabilis na Balangkas

Ipapakita ng post na ito:

Paano Ipapatupad ang ReAct Logic Gamit ang isang Ahente sa LangChain?

Ang ' ReAct ' ay ang kumbinasyon ng mga yugto ng Dahilan at Aksyon upang mapahusay ang pagganap ng modelo ng wika bilang ' Re 'ay tumutukoy sa dahilan at' Kumilos ” sa pagkilos. Ang lohika ng ReAct ay madalas na itinuturing na pinaka-optimize para sa pagbuo ng mga LLM o chatbot upang maunawaan at makabuo ng teksto. Ang ahente ay ang gumagawa ng desisyon na nagpapasya kung aling mga aksyon ang gagawin at kung anong pagkakasunud-sunod ang isasagawa.







Upang matutunan ang proseso ng pagpapatupad ng ReAct logic gamit ang isang ahente sa LangChain, dumaan lang sa sumusunod na gabay:



Hakbang 1: Pag-install ng Mga Framework

Una sa lahat, i-install ang LangChain para makapagsimula sa proseso ng pagpapatupad ng ReAct logic:



pip install langchain





I-install ang module ng google-search-results upang makuha ang mga dependency para sa pagbuo ng ahente na makakakuha ng mga resulta ng paghahanap mula sa google:

pip install openai google-search-results



Pagkatapos nito, i-install ang OpenAI modules na maaaring magamit para i-load ang Large Language Models o LLMs para ipatupad ang ReAct logic:

pip install openai

Pagkatapos makuha ang lahat ng kinakailangang module, i-set up lang ang OpenAI na kapaligiran para sa pagtatayo ng LLM at kapaligiran ng SerpAPI para sa paggamit ng ahente sa modelo:

angkat ikaw

angkat getpass

ikaw . humigit-kumulang [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'OpenAI API Key:' )

ikaw . humigit-kumulang [ 'SERPAPI_API_KEY' ] = getpass . getpass ( 'Serpapi API Key:' )

Hakbang 2: Nilo-load ang Modelo ng Wika

Ang susunod na hakbang ay ang paglo-load ng mga modelo ng wika sa pamamagitan ng pag-import ng mga kinakailangang aklatan gamit ang LangChain framework:

mula sa langchain. mga ahente angkat load_tools

mula sa langchain. mga ahente angkat initialize_agent

mula sa langchain. mga ahente angkat Uri ng Ahente

mula sa langchain. llms angkat OpenAI

Gamitin ang paraan ng OpenAI() upang bumuo ng Modelo ng Wika (llm) at pagkatapos ay i-configure ang mga tool para sa mga ahente gamit ang SerpAPI:

llm = OpenAI ( temperatura = 0 )

mga kasangkapan = load_tools ( [ 'serpapi' , 'llm-math' ] , llm = llm )

Paraan 1: Paggamit ng LandChain Expression Language

Ang LCEL ay ang proseso ng pagsasama-sama o pagbubuo ng mga chain habang binubuo ang mga modelo ng wika sa LangChain. Simulan ang proseso sa pamamagitan ng pag-install ng LangChainHub para makuha ang mga dependency nito para sa pagbuo at paggamit ng ReAct logic sa mga ahente sa LangChain:

pip install langchainhub

Ang pag-import ng mga aklatan mula sa LangChain tulad ng ReActSingleInputOutputParser upang bumuo ng modelo na maaaring gumamit ng modelo ng ReAct:

mula sa langchain. mga kasangkapan . render angkat render_text_description

mula sa langchain. mga ahente . output_parsers angkat ReActSingleInputOutputParser

mula sa langchain. mga ahente . format_scratchpad angkat format_log_to_str

mula sa langchain angkat hub

I-load ang modelo ng wika upang idisenyo ang ReAct logic gamit ang pull() na paraan at iimbak ito sa prompt variable. Tukuyin ang ilang tool na magagamit para ipatupad ang logic sa na-load na dataset para ipatupad ang pagtatrabaho nito sa isang ahente:

prompt = hub. hilahin ( 'hwchase17/react' )

prompt = prompt. bahagyang (

mga kasangkapan = render_text_description ( mga kasangkapan ) ,

tool_name = ',' . sumali ( [ t. pangalan para sa t sa mga kasangkapan ] ) ,

)

Ahente ng Building

Ngayon, i-configure ang ahente at ang mga tool nito sa pamamagitan ng pagsasama nito sa modelo ng wika na na-load sa hakbang 2 ng gabay na ito:

llm_with_stop = llm. magbigkis ( huminto = [ ' \n Pagmamasid' ] )

Tukuyin ang isang variable ng ahente upang ibigay ang mga argumento at tool upang i-configure ang ahente na nagpapaliwanag sa paggana nito. Ang mga naunang na-configure na bahagi tulad ng llm_with_stop at ReActSingleInputOutputParser() na pamamaraan ay isinasama sa ahente:

ahente = {

'input' : lambda x: x [ 'input' ] ,

'agent_scratchpad' : lambda x: format_log_to_str ( x [ 'intermediate_steps' ] )

} | prompt | llm_with_stop | ReActSingleInputOutputParser ( )

Kunin ang library ng AgentExecutor at i-configure ang pamamaraan nito gamit ang mga argumento tulad ng ahente, mga tool, at verbose upang makakuha ng mas nababasang output:

mula sa langchain. mga ahente angkat AgentExecutor

agent_executor = AgentExecutor ( ahente = ahente , mga kasangkapan = mga kasangkapan , verbose = totoo )

I-invoke ang agent_executor() method na may string query bilang input na magti-trigger sa agent na kunin ang output:

agent_executor. panawagan ( { 'input' : 'Sino ang kasintahan ni Leo DiCaprio' } )

Output

Ang sumusunod na screenshot ay nagpapakita na kinuha ng ahente ang impormasyon gamit ang ReAct logic at nabuo ang teksto sa natural na wika:

Paraan 2: Paggamit ng ZeroShotReactAgent

Ang lohika ng ReAct ay maaari ding ipatupad sa pamamagitan ng paggamit ng isa pang ahente tulad ng ZeroShotReactAgent habang kino-configure ang variable na agent_executor. Pagkatapos nito, tawagan lang ang variable na agent_executor na may tanong bilang input para ma-invoke ang ahente:

agent_executor = initialize_agent ( mga kasangkapan , llm , ahente = Uri ng Ahente. ZERO_SHOT_REACT_DESCRIPTION , verbose = totoo )

agent_executor. panawagan ( { 'input' : 'Ano ang edad ng kasintahan ni Leo DiCaprio na itinaas sa 0.21 na kapangyarihan' } )

Output

Kinuha ng ahente ang impormasyon batay sa input na hiniling habang hinihiling ang agent_executor:

Paraan 3: Paggamit ng Mga Modelo ng Chat

Isa pang proseso na maaaring magamit upang ipatupad ang ReAct logic sa pamamagitan ng paggamit ng mga modelo ng chat pagkatapos i-import ang ChatOpenAI library:

mula sa langchain. chat_models angkat ChatOpenAI

Buuin ang modelo ng chat gamit ang ChatOpenAI() na paraan na may halaga ng temperatura na katumbas ng 0 na maaaring makontrol ang randomness sa mga resulta ng modelo:

chat_model = ChatOpenAI ( temperatura = 0 )

I-load ang modelo kung saan maaaring ipatupad ng user ang ReAct logic para iimbak ito sa prompt variable at i-configure ang mga tool na gagamitin sa proseso:

prompt = hub. hilahin ( 'hwchase17/react-json' )

prompt = prompt. bahagyang (

mga kasangkapan = render_text_description ( mga kasangkapan ) ,

tool_name = ',' . sumali ( [ t. pangalan para sa t sa mga kasangkapan ] ) ,

)

Pagbuo ng Ahente

Gamitin ang modelo ng chat upang iimbak ang mga obserbasyon o kamakailang mga mensahe kapag huminto ang modelo sa pagbuo ng teksto:

chat_model_with_stop = chat_model. magbigkis ( huminto = [ ' \n Pagmamasid' ] )

Kunin ang ReActJsonSingleInputOutputParser library para ipatupad ang ReAct logic at gawin ang mga resulta sa JSON format:

mula sa langchain. mga ahente . output_parsers angkat ReActJsonSingleInputOutputParser

Buuin at i-configure ang ahente gamit ang chat_model variable at paraan upang makagawa ng mga resulta sa pamamagitan ng pagtawag sa ahente:

ahente = {

'input' : lambda x: x [ 'input' ] ,

'agent_scratchpad' : lambda x: format_log_to_str ( x [ 'intermediate_steps' ] )

} | prompt | chat_model_with_stop | ReActJsonSingleInputOutputParser ( )

I-configure ang agent_executor at patakbuhin ito upang makuha ang mga resulta batay sa query na ibinigay sa input variable:

agent_executor = AgentExecutor ( ahente = ahente , mga kasangkapan = mga kasangkapan , verbose = totoo )

agent_executor. panawagan ( { 'input' : 'Ano ang edad ng kasintahan ni Leo DiCaprio na itinaas sa 0.21 na kapangyarihan' } )

Output

Kinuha ng ahente ang output gaya ng ipinapakita sa sumusunod na screenshot:

Paraan 4: Paggamit ng ChatZeroShotReactAgent

Ang pagpapalit ng halaga ng ahente ay maaari ding gamitin upang ipatupad ang ReAct logic sa LangChain framework:

ahente = initialize_agent ( mga kasangkapan , chat_model , ahente = Uri ng Ahente. CHAT_ZERO_SHOT_REACT_DESCRIPTION , verbose = totoo )

ahente. tumakbo ( 'Ano ang edad ng kasintahan ni Leo DiCaprio na itinaas sa 0.21 na kapangyarihan' )

Output

Ang istraktura ng output ay naglalaman ng detalyadong impormasyon tungkol sa pagtatrabaho ng ahente mula sa mga token at modelong ginamit upang kunin ang impormasyon:

Iyon lang ang tungkol sa proseso ng pagpapatupad ng ReAct logic gamit ang isang ahente sa LangChain.

Konklusyon

Para ipatupad ang ReAct logic sa isang ahente gamit ang LangChain framework, mag-install ng mga module tulad ng google-search-results para i-configure ang ahente. Pagkatapos nito, i-set up ang kapaligiran gamit ang mga kredensyal ng OpenAI at SerpAPI mula sa kanilang mga account upang simulan ang paggamit ng modelo. Maaaring ipatupad ang lohika ng ReAct gamit ang LCEL at mga modelo ng chat na may maraming ahente na inaalok ng module ng LangChain. Ang gabay na ito ay nagpapaliwanag sa pagpapatupad ng ReAct logic gamit ang ahente sa LangChain.