Rask oversikt
Dette innlegget vil demonstrere følgende:
Hvordan implementere Self-Ask med søkekjeden
- Installere Frameworks
- Bygningsmiljø
- Importerer biblioteker
- Bygge språkmodeller
- Bruker LangChain Expression Language
- Konfigurere Agent Executor
- Kjøre agenten
- Bruker Self-Ask Agent
Hvordan implementere Self-Ask med søkekjeden?
Self-Ask er prosessen for å forbedre kjedeprosessen ettersom den forstår kommandoene grundig. Kjedene forstår spørsmålet ved å trekke ut dataene om alle de viktige termene fra datasettet. Når modellen er opplært og forstår spørringen, genererer den svaret på spørringen som blir spurt av brukeren.
For å lære prosessen med å implementere selvspørringen med søkekjedene i LangChain, gå ganske enkelt gjennom følgende veiledning:
Trinn 1: Installere Frameworks
Først av alt, start prosessen ved å installere LangChain-prosessen ved å bruke følgende kode og få alle avhengighetene for prosessen:
pip installer langkjede
Etter å ha installert LangChain, installer ' google-søk-resultater ' for å få søkeresultatene fra Google ved å bruke OpenAI-miljøet:
pip installer openai google-søk-resultater 
Trinn 2: Byggemiljø
Når modulene og rammeverket er installert, sett opp miljøet for OpenAI og SerpAPi ved å bruke deres API-er ved å bruke følgende kode. Importer OS- og getpass-bibliotekene som kan brukes til å legge inn API-nøklene fra deres respektive kontoer:
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 3: Importere biblioteker
Etter å ha satt opp miljøet, importerer du ganske enkelt de nødvendige bibliotekene fra LangChain-avhengighetene som verktøy, agenter, llm og andre:
fra langkjede. llms import OpenAIfra langkjede. verktøy import SerpAPIWrapper
fra langkjede. agenter . output_parsere import SelfAskOutputParser
fra langkjede. agenter . format_scratchpad import format_log_to_str
fra langkjede import hub
fra langkjede. agenter import initialize_agent , Verktøy
fra langkjede. agenter import AgentType
Trinn 4: Bygge språkmodeller
Å få tak i bibliotekene ovenfor er nødvendig gjennom hele prosessen da OpenAI() brukes til å konfigurere språkmodellen. Bruk SerpAPIWrapper()-metoden for å konfigurere søkevariabelen og angi verktøyene som kreves for at agenten skal utføre alle oppgavene:
llm = OpenAI ( temperatur = 0 )Søk = SerpAPIWrapper ( )
verktøy = [
Verktøy (
Navn = 'Mellomsvar' ,
func = Søk. løpe ,
beskrivelse = 'nyttig når du trenger å spørre med søk' ,
)
]
Trinn 5: Bruke LangChain Expression Language
Komme i gang med å konfigurere agenten ved å bruke LangChain Expression Language (LCEL) ved å laste modellen i ledetekstvariabelen:
ledetekst = hub. dra ( 'hwchase17/self-ask-with-search' )Definer en annen variabel som kan kjøres for å stoppe generering av tekst og kontrollere lengden på svarene:
llm_with_stop = llm. binde ( Stoppe = [ ' \n Mellomsvar:' ] )Konfigurer nå agentene ved å bruke Lambda, som er en hendelsesdrevet serverløs plattform for å generere svarene på spørsmålene. Konfigurer også trinnene som trengs for å trene og teste modellen for å få de optimaliserte resultatene ved å bruke komponentene som er konfigurert tidligere:
middel = {'inngang' : lambda x: x [ 'inngang' ] ,
'agent_scratchpad' : lambda x: format_log_to_str (
x [ 'mellomsteg' ] ,
observasjonsprefiks = ' \n Mellomsvar: ' ,
llm_prefiks = '' ,
) ,
} | ledetekst | llm_with_stop | SelfAskOutputParser ( )
Trinn 6: Konfigurere Agent Executor
Før du tester metoden, importerer du bare AgentExecutor-biblioteket fra LangChain for å gjøre agenten responsiv:
fra langkjede. agenter import AgentExecutorDefiner agent_executor-variabelen ved å kalle AgentExecutor()-metoden og bruke komponentene som argumenter:
agent_executor = AgentExecutor ( middel = middel , verktøy = verktøy , ordrik = ekte )Trinn 7: Kjøre agenten
Når agentutføreren er konfigurert, test den ganske enkelt ved å gi spørsmålet/ledeteksten i inngangsvariabelen:
agent_executor. påkalle ( { 'inngang' : 'Hvem er U.S. Open-mesteren for menn' } )Utførelse av koden ovenfor har svart med navnet til US Open Champion i utdataene, dvs. Dominic Thiem:
Trinn 8: Bruk av Self-Ask Agent
Etter å ha fått svar fra agenten, bruk SELF_ASK_WITH_SEARCH agent med spørringen i run()-metoden:
selv_spør_med_søk = initialize_agent (verktøy , llm , middel = AgentType. SELF_ASK_WITH_SEARCH , ordrik = ekte
)
selv_spør_med_søk. løpe (
'Hva er hjembyen til Dominic Thiem, US Open World Champion'
)
Følgende skjermbilde viser at selvspørringsagenten trekker ut informasjonen om hvert viktig begrep fra datasettet. Når den har samlet all informasjon om spørringen og forstår spørsmålene, genererer den ganske enkelt svaret. Spørsmålene agenten selv har stilt er:
- Hvem er Dominic Thiem?
- Hva er hjembyen til Dominic Thiem?
Etter å ha fått svar på disse spørsmålene, har agenten generert svaret på det opprinnelige spørsmålet som er ' Wiener Neustadt, Østerrike ':
Det handler om prosessen med å implementere selvspørringen med en søkekjede ved å bruke LangChain-rammeverket.
Konklusjon
For å implementere selvspørringen med søk i LangChain, installer ganske enkelt de nødvendige modulene som google-search-results for å få resultatene fra agenten. Deretter setter du opp miljøet ved å bruke API-nøklene fra OpenAI- og SerpAPi-kontoene for å komme i gang med prosessen. Konfigurer agenten og bygg modellen med selvspørringsmodellen for å teste den ved å bruke AgentExecutor()-metoden.