Rask oversikt
Dette innlegget vil demonstrere:
- Hvordan implementere ReAct-logikken ved å bruke en agent i LangChain
- Installere Frameworks
- Laster språkmodell
- Metode 1: Bruke LandChain Expression Language
- Byggeagent
- Metode 2: Bruke ZeroShotReactAgent
- Metode 3: Bruke Chat-modeller
- Bygge agenten
- Metode 4: Bruke ChatZeroShotReactAgent
- Konklusjon
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 duimport 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_toolsfra 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_descriptionfra 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 AgentExecutoragent_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 ChatOpenAIBygg 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 ReActJsonSingleInputOutputParserBygg 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.