Hvordan implementere ReAct-logikken ved å bruke en agent i LangChain?

Hvordan Implementere React Logikken Ved A Bruke En Agent I Langchain



LangChain er rammeverket for å bygge språkmodeller og chatbots som kan forstå og generere tekst på menneskelig språk. Modellens ytelse er basert på forståelsen av språket og dets kompleksitet under opplæringsfasen av prosessen. Den neste fasen er å generere data eller tekst på det naturlige språket som kan være lett lesbart og forståelig. Disse fasene blir referert til som ' Argumentasjon ' og ' Fungerende ” henholdsvis i Natural Language Processing-domenet.

Rask oversikt

Dette innlegget vil demonstrere:

Hvordan implementere ReAct-logikken ved å bruke en agent i LangChain?

« Reagere ' er kombinasjonen av grunn- og handlingsfasene for å forbedre ytelsen til språkmodellen som ' Re ' refererer til fornuft og ' Handling ' til handling. En ReAct-logikk regnes ofte som den mest optimaliserte for å bygge LLM-er eller chatboter for å forstå og generere tekst. Agenten er beslutningstakeren som bestemmer hvilke handlinger som skal utføres og i hvilken rekkefølge som skal utføres.







For å lære prosessen med å implementere ReAct-logikken ved å bruke en agent i LangChain, gå ganske enkelt gjennom følgende veiledning:



Trinn 1: Installere Frameworks

Først av alt, installer LangChain for å komme i gang med prosessen med å implementere ReAct-logikk:



pip installer langkjede





Installer google-search-results-modulen for å få avhengighetene for å bygge agenten som kan hente søkeresultatene fra google:

pip installer openai google-søk-resultater



Etter det, installer OpenAI-modulene som kan brukes til å laste de store språkmodellene eller LLM-ene for å implementere ReAct-logikk:

pip installer openai

Etter å ha fått alle nødvendige moduler, konfigurerer du bare OpenAI-miljø for å bygge LLM og SerpAPI miljø for bruk av agenten i modellen:

import du

import få pass

du . omtrent [ 'OPENAI_API_KEY' ] = få pass . få pass ( 'OpenAI API Key:' )

du . omtrent [ 'SERPAPI_API_KEY' ] = få pass . få pass ( 'Serpapi API-nøkkel:' )

Trinn 2: Laster språkmodell

Det neste trinnet er å laste inn språkmodellene ved å importere de nødvendige bibliotekene ved å bruke LangChain-rammeverket:

fra langkjede. agenter import load_tools

fra langkjede. agenter import initialize_agent

fra langkjede. agenter import AgentType

fra langkjede. llms import OpenAI

Bruk OpenAI()-metoden for å bygge språkmodellen (llm) og konfigurer deretter verktøyene for agentene ved hjelp av SerpAPI:

llm = OpenAI ( temperatur = 0 )

verktøy = load_tools ( [ 'serpapi' , 'llm-matte' ] , llm = llm )

Metode 1: Bruke LandChain Expression Language

LCEL er prosessen med å integrere eller komponere kjeder sammen mens man bygger språkmodellene i LangChain. Start prosessen ved å installere LangChainHub for å få dens avhengigheter for å bygge og bruke ReAct-logikk med agenter i LangChain:

pip installer langchainhub

Importere bibliotekene fra LangChain som ReActSingleInputOutputParser for å bygge modellen som kan bruke ReAct-modellen:

fra langkjede. verktøy . gjengi import render_text_description

fra langkjede. agenter . output_parsere import ReActSingleInputOutputParser

fra langkjede. agenter . format_scratchpad import format_log_to_str

fra langkjede import hub

Last inn språkmodellen for å designe ReAct-logikken ved å bruke pull()-metoden og lagre den i ledetekstvariabelen. Definer noen verktøy som kan brukes til å implementere logikken på det lastede datasettet for å implementere dets arbeid med en agent:

ledetekst = hub. dra ( 'hwchase17/react' )

ledetekst = ledetekst. delvis (

verktøy = render_text_description ( verktøy ) ,

verktøynavn = ', ' . bli med ( [ t. Navn til t i verktøy ] ) ,

)

Byggeagent

Konfigurer nå agenten og dens verktøy ved å integrere den med språkmodellen lastet i trinn 2 i denne veiledningen:

llm_with_stop = llm. binde ( Stoppe = [ ' \n Observasjon' ] )

Definer en agentvariabel for å gi argumentene og verktøyene for å konfigurere agenten som forklarer hvordan den fungerer. De tidligere konfigurerte delene som llm_with_stop og ReActSingleInputOutputParser()-metoden blir integrert med agenten:

middel = {

'inngang' : lambda x: x [ 'inngang' ] ,

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

} | ledetekst | llm_with_stop | ReActSingleInputOutputParser ( )

Skaff deg AgentExecutor-biblioteket og konfigurer metoden ved hjelp av argumenter som agent, verktøy og detaljert for å få en mer lesbar utgang:

fra langkjede. agenter import AgentExecutor

agent_executor = AgentExecutor ( middel = middel , verktøy = verktøy , ordrik = ekte )

Påkall agent_executor()-metoden med strengspørringen som input som vil trigge agenten til å trekke ut utdataene:

agent_executor. påkalle ( { 'inngang' : 'Hvem er Leo DiCaprios kjæreste' } )

Produksjon

Følgende skjermbilde viser at agenten har trukket ut informasjonen ved hjelp av ReAct-logikken og generert teksten på naturlig språk:

Metode 2: Bruke ZeroShotReactAgent

ReAct-logikken kan også implementeres ved å bruke en annen agent som ZeroShotReactAgent mens du konfigurerer agent_executor-variabelen. Deretter kaller du bare agent_executor-variabelen med spørsmålet som input for å påkalle agenten:

agent_executor = initialize_agent ( verktøy , llm , middel = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ordrik = ekte )

agent_executor. påkalle ( { 'inngang' : 'Hva er Leo DiCaprios kjærestealder hevet til 0,21-styrken' } )

Produksjon

Agenten har hentet ut informasjonen basert på inndataene som ble spurt mens han påkalte agent_executor:

Metode 3: Bruke Chat-modeller

En annen prosess som kan brukes til å implementere ReAct-logikken ved å bruke chat-modellene etter import av ChatOpenAI-biblioteket:

fra langkjede. chat_modeller import ChatOpenAI

Bygg chat-modellen ved å bruke ChatOpenAI()-metoden med verdien av temperatur lik 0 som kan kontrollere tilfeldigheten i resultatene av modellen:

chat_model = ChatOpenAI ( temperatur = 0 )

Last inn modellen som brukeren kan implementere ReAct-logikken på for å lagre den i ledetekstvariabelen og konfigurer verktøyene som skal brukes i prosessen:

ledetekst = hub. dra ( 'hwchase17/react-json' )

ledetekst = ledetekst. delvis (

verktøy = render_text_description ( verktøy ) ,

verktøynavn = ', ' . bli med ( [ t. Navn til t i verktøy ] ) ,

)

Bygge agenten

Bruk chat-modellen til å lagre observasjonene eller nylige meldinger når modellen slutter å generere teksten:

chat_modell_med_stopp = chat_model. binde ( Stoppe = [ ' \n Observasjon' ] )

Få ReActJsonSingleInputOutputParser-biblioteket for å implementere ReAct-logikken og produsere resultatene i JSON-formatet:

fra langkjede. agenter . output_parsere import ReActJsonSingleInputOutputParser

Bygg og konfigurer agenten ved å bruke chat_model-variabelen og -metoden for å produsere resultater ved å ringe agenten:

middel = {

'inngang' : lambda x: x [ 'inngang' ] ,

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

} | ledetekst | chat_model_with_stop | ReActJsonSingleInputOutputParser ( )

Konfigurer agent_executor og kjør den for å få resultatene basert på spørringen i inngangsvariabelen:

agent_executor = AgentExecutor ( middel = middel , verktøy = verktøy , ordrik = ekte )

agent_executor. påkalle ( { 'inngang' : 'Hva er Leo DiCaprios kjærestealder hevet til 0,21-styrken' } )

Produksjon

Agenten har trukket ut utdataene som vist i følgende skjermbilde:

Metode 4: Bruke ChatZeroShotReactAgent

Endring av verdien til agenten kan også brukes til å implementere ReAct-logikken med LangChain-rammeverket:

middel = initialize_agent ( verktøy , chat_model , middel = AgentType. CHAT_ZERO_SHOT_REACT_DESCRIPTION , ordrik = ekte )

middel. løpe ( 'Hva er Leo DiCaprios kjærestealder hevet til 0,21-styrken' )

Produksjon

Utdatastrukturen inneholder detaljert informasjon om virkemåten til agenten fra tokens og modellen som ble brukt for å trekke ut informasjonen:

Det handler om prosessen med å implementere ReAct-logikken ved å bruke en agent i LangChain.

Konklusjon

For å implementere ReAct-logikken med en agent som bruker LangChain-rammeverket, installer moduler som google-search-results for å konfigurere agenten. Deretter setter du opp miljøet ved å bruke OpenAI- og SerpAPI-legitimasjonen fra kontoene deres for å begynne å bruke modellen. ReAct-logikken kan implementeres ved å bruke LCEL- og chat-modellene med flere agenter som tilbys av LangChain-modulen. Denne veiledningen har utdypet implementeringen av ReAct-logikken ved å bruke agenten i LangChain.