Ako implementovať logiku ReAct pomocou agenta v LangChain?

' ReAct “ je kombináciou fáz Reason a Action na zvýšenie výkonu jazykového modelu ako „ Re “ odkazuje na dôvod a „ zák “do akcie. Logika ReAct sa často považuje za najviac optimalizovanú na vytváranie LLM alebo chatbotov na pochopenie a generovanie textu. Agent je osoba s rozhodovacou právomocou, ktorá rozhoduje o tom, ktoré akcie sa majú vykonať a v akom poradí sa budú vykonávať.

Ak sa chcete naučiť proces implementácie logiky ReAct pomocou agenta v LangChain, prejdite si nasledujúcu príručku:

Krok 1: Inštalácia rámcov

Najprv si nainštalujte LangChain, aby ste mohli začať s procesom implementácie logiky ReAct:

pip install langchain

Nainštalujte modul google-search-results, aby ste získali závislosti na zostavenie agenta, ktorý môže získať výsledky vyhľadávania z google:

pip install openai google-search-results

Potom nainštalujte moduly OpenAI, ktoré možno použiť na načítanie veľkých jazykových modelov alebo LLM na implementáciu logiky ReAct:

pip install openai

Po získaní všetkých požadovaných modulov jednoducho nastavte Prostredie OpenAI na budovanie LLM a Prostredie SerpAPI na použitie agenta v modeli:

importovať vy

importovať getpass

vy . približne [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'OpenAI API Key:' )

vy . približne [ 'SERPAPI_API_KEY' ] = getpass . getpass ( 'Serpapi API Key:' )

Krok 2: Načítanie jazykového modelu

Ďalším krokom je načítanie jazykových modelov importovaním požadovaných knižníc pomocou rámca LangChain:

od langchain. agentov importovať load_tools

od langchain. agentov importovať initialize_agent

od langchain. agentov importovať Typ agenta

od langchain. llms importovať OpenAI

Pomocou metódy OpenAI() vytvorte jazykový model (llm) a potom nakonfigurujte nástroje pre agentov pomocou SerpAPI:

llm = OpenAI ( teplota = 0 )

nástrojov = load_tools ( [ 'serpapi' , 'llm-math' ] , llm = llm )

Metóda 1: Použitie jazyka LandChain Expression Language

LCEL je proces integrácie alebo skladania reťazcov pri vytváraní jazykových modelov v LangChain. Začnite proces inštaláciou LangChainHub, aby ste získali jeho závislosti na budovanie a používanie logiky ReAct s agentmi v LangChain:

pip nainštalujte langchainhub

Importovanie knižníc z LangChain, ako je ReActSingleInputOutputParser na vytvorenie modelu, ktorý môže používať model ReAct:

od langchain. nástrojov . vykresliť importovať render_text_description

od langchain. agentov . výstupné_analyzátory importovať ReActSingleInputOutputParser

od langchain. agentov . format_scratchpad importovať format_log_to_str

od langchain importovať stredisko

Načítajte jazykový model na návrh logiky ReAct pomocou metódy pull() a uložte ho do premennej výzvy. Definujte niektoré nástroje, ktoré možno použiť na implementáciu logiky na načítanej množine údajov na implementáciu jej práce s agentom:

výzva = stredisko. SEM ( 'hwchase17/react' )

výzva = výzva. čiastočné (

nástrojov = render_text_description ( nástrojov ) ,

názvy_nástrojov = ',' . pripojiť sa ( [ t. názov pre t v nástrojov ] ) ,

)

Stavebný agent

Teraz nakonfigurujte agenta a jeho nástroje integráciou s jazykovým modelom načítaným v kroku 2 tejto príručky:

llm_with_stop = llm. viazať ( zastaviť = [ ' \n pozorovanie' ] )

Definujte premennú agenta, aby ste poskytli argumenty a nástroje na konfiguráciu agenta, ktoré vysvetľujú jeho fungovanie. Predtým nakonfigurované časti ako llm_with_stop a metóda ReActSingleInputOutputParser() sa integrujú s agentom:

agent = {

'vstup' : lambda x: x [ 'vstup' ] ,

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

} | výzva | llm_with_stop | ReActSingleInputOutputParser ( )

Získajte knižnicu AgentExecutor a nakonfigurujte jej metódu pomocou argumentov, ako sú agent, nástroje a podrobné informácie, aby ste získali čitateľnejší výstup:

od langchain. agentov importovať AgentExecutor

agent_exekútor = AgentExecutor ( agent = agent , nástrojov = nástrojov , podrobný = Pravda )

Vyvolajte metódu agent_executor() s reťazcovým dotazom ako vstupom, ktorý spustí agenta na extrakciu výstupu:

agent_exekútor. vzývať ( { 'vstup' : 'Kto je priateľka Lea DiCapria?' } )

Výkon

Nasledujúca snímka obrazovky zobrazuje, že agent extrahoval informácie pomocou logiky ReAct a vygeneroval text v prirodzenom jazyku:

Metóda 2: Použitie ZeroShotReactAgent

Logiku ReAct je možné implementovať aj pomocou iného agenta, ako je ZeroShotReactAgent, pri konfigurácii premennej agent_executor. Potom jednoducho zavolajte premennú agent_executor s otázkou ako vstupom na vyvolanie agenta:

agent_exekútor = initialize_agent ( nástrojov , llm , agent = Typ agenta. ZERO_SHOT_REACT_DESCRIPTION , podrobný = Pravda )

agent_exekútor. vzývať ( { 'vstup' : 'Aký je vek priateľky Lea DiCapria zvýšený na mocninu 0,21' } )

Výkon

Agent extrahoval informácie na základe zadania požadovaného pri vyvolaní agent_executor:

Metóda 3: Používanie modelov rozhovoru

Ďalší proces, ktorý možno použiť na implementáciu logiky ReAct pomocou modelov chatu po importovaní knižnice ChatOpenAI:

od langchain. chat_models importovať ChatOpenAI

Zostavte model chatu pomocou metódy ChatOpenAI() s hodnotou teploty rovnou 0, ktorá môže kontrolovať náhodnosť výsledkov modelu:

chat_model = ChatOpenAI ( teplota = 0 )

Načítajte model, na ktorom môže používateľ implementovať logiku ReAct, aby ju uložil do premennej výzvy a nakonfigurujte nástroje, ktoré sa majú v procese použiť:

výzva = stredisko. SEM ( 'hwchase17/react-json' )

výzva = výzva. čiastočné (

nástrojov = render_text_description ( nástrojov ) ,

názvy_nástrojov = ',' . pripojiť sa ( [ t. názov pre t v nástrojov ] ) ,

)

Budovanie agenta

Keď model prestane generovať text, použite model rozhovoru na ukladanie pozorovaní alebo nedávnych správ:

chat_model_with_stop = chat_model. viazať ( zastaviť = [ ' \n pozorovanie' ] )

Získajte knižnicu ReActJsonSingleInputOutputParser na implementáciu logiky ReAct a vytváranie výsledkov vo formáte JSON:

od langchain. agentov . výstupné_analyzátory importovať ReActJsonSingleInputOutputParser

Zostavte a nakonfigurujte agenta pomocou premennej a metódy chat_model, aby ste dosiahli výsledky volaním agenta:

agent = {

'vstup' : lambda x: x [ 'vstup' ] ,

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

} | výzva | chat_model_with_stop | ReActJsonSingleInputOutputParser ( )

Nakonfigurujte agent_executor a spustite ho, aby ste získali výsledky na základe dotazu poskytnutého vo vstupnej premennej:

agent_exekútor = AgentExecutor ( agent = agent , nástrojov = nástrojov , podrobný = Pravda )

agent_exekútor. vzývať ( { 'vstup' : 'Aký je vek priateľky Lea DiCapria zvýšený na mocninu 0,21' } )

Výkon

Agent extrahoval výstup, ako je zobrazené na nasledujúcej snímke obrazovky:

Metóda 4: Použitie ChatZeroShotReactAgent

Zmenu hodnoty agenta možno použiť aj na implementáciu logiky ReAct s rámcom LangChain:

agent = initialize_agent ( nástrojov , chat_model , agent = Typ agenta. CHAT_ZERO_SHOT_REACT_DESCRIPTION , podrobný = Pravda )

agent. behať ( 'Aký je vek priateľky Lea DiCapria zvýšený na mocninu 0,21' )

Výkon

Výstupná štruktúra obsahuje podrobné informácie o fungovaní agenta z tokenov a modelu použitého na extrahovanie informácií:

To je všetko o procese implementácie logiky ReAct pomocou agenta v LangChain.

Záver

Ak chcete implementovať logiku ReAct s agentom pomocou rámca LangChain, nainštalujte moduly ako google-search-results na konfiguráciu agenta. Potom nastavte prostredie pomocou poverení OpenAI a SerpAPI z ich účtov, aby ste mohli začať používať model. Logiku ReAct je možné implementovať pomocou modelov LCEL a chat s viacerými agentmi, ktoré ponúka modul LangChain. Táto príručka rozpracovala implementáciu logiky ReAct pomocou agenta v LangChain.

Ako implementovať logiku ReAct pomocou agenta v LangChain?

Rýchly prehľad