సెర్చ్ చైన్‌తో సెల్ఫ్-అస్క్‌ని ఎలా అమలు చేయాలి?

సెల్ఫ్-అస్క్ అనేది కమాండ్‌లను క్షుణ్ణంగా అర్థం చేసుకున్నందున చైనింగ్ ప్రక్రియను మెరుగుపరిచే ప్రక్రియ. డేటాసెట్ నుండి అన్ని ముఖ్యమైన నిబంధనల గురించి డేటాను సంగ్రహించడం ద్వారా గొలుసులు ప్రశ్నను అర్థం చేసుకుంటాయి. మోడల్ శిక్షణ పొంది, ప్రశ్నను అర్థం చేసుకున్న తర్వాత, అది వినియోగదారు అడిగిన ప్రశ్నకు ప్రతిస్పందనను రూపొందిస్తుంది.

LangChainలోని శోధన గొలుసులతో స్వీయ-అడుగును అమలు చేసే ప్రక్రియను తెలుసుకోవడానికి, క్రింది గైడ్ ద్వారా వెళ్ళండి:

దశ 1: ఫ్రేమ్‌వర్క్‌లను ఇన్‌స్టాల్ చేయడం

అన్నింటిలో మొదటిది, కింది కోడ్‌ని ఉపయోగించి LangChain ప్రక్రియను ఇన్‌స్టాల్ చేయడం ద్వారా ప్రక్రియను ప్రారంభించండి మరియు ప్రక్రియ కోసం అన్ని డిపెండెన్సీలను పొందండి:

పిప్ ఇన్‌స్టాల్ లాంగ్‌చెయిన్

LangChainని ఇన్‌స్టాల్ చేసిన తర్వాత, “ని ఇన్‌స్టాల్ చేయండి గూగుల్-సెర్చ్-ఫలితాలు ” OpenAI పర్యావరణాన్ని ఉపయోగించి Google నుండి శోధన ఫలితాలను పొందడానికి:

pip ఇన్స్టాల్ openai google-search-results

దశ 2: పర్యావరణాన్ని నిర్మించడం

మాడ్యూల్స్ మరియు ఫ్రేమ్‌వర్క్‌లు ఇన్‌స్టాల్ చేయబడిన తర్వాత, దాని కోసం పర్యావరణాన్ని సెటప్ చేయండి OpenAI మరియు SerpAPi కింది కోడ్‌ని ఉపయోగించి వారి APIలను ఉపయోగించడం. వాటి సంబంధిత ఖాతాల నుండి API కీలను నమోదు చేయడానికి ఉపయోగించే os మరియు getpass లైబ్రరీలను దిగుమతి చేయండి:

దిగుమతి మీరు
దిగుమతి getpass

మీరు . సుమారు [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'OpenAI API కీ:' )
మీరు . సుమారు [ 'SERPAPI_API_KEY' ] = getpass . getpass ( 'Serpapi API కీ:' )

దశ 3: లైబ్రరీలను దిగుమతి చేసుకోవడం

పర్యావరణాన్ని సెటప్ చేసిన తర్వాత, వినియోగాలు, ఏజెంట్లు, llm మరియు ఇతరాలు వంటి LangChain డిపెండెన్సీల నుండి అవసరమైన లైబ్రరీలను దిగుమతి చేసుకోండి:

నుండి లాంగ్చైన్. llms దిగుమతి OpenAI

నుండి లాంగ్చైన్. యుటిలిటీస్ దిగుమతి SerpAPIWrapper

నుండి లాంగ్చైన్. ఏజెంట్లు . అవుట్‌పుట్_పార్సర్‌లు దిగుమతి SelfAskOutputParser

నుండి లాంగ్చైన్. ఏజెంట్లు . ఫార్మాట్_స్క్రాచ్‌ప్యాడ్ దిగుమతి format_log_to_str

నుండి లాంగ్చైన్ దిగుమతి హబ్

నుండి లాంగ్చైన్. ఏజెంట్లు దిగుమతి ప్రారంభించు_ఏజెంట్ , సాధనం

నుండి లాంగ్చైన్. ఏజెంట్లు దిగుమతి ఏజెంట్ రకం

దశ 4: బిల్డింగ్ లాంగ్వేజ్ మోడల్స్

భాషా నమూనాను కాన్ఫిగర్ చేయడానికి OpenAI() ఉపయోగించబడుతుంది కాబట్టి పై లైబ్రరీలను పొందడం ప్రక్రియ అంతటా అవసరం. శోధన వేరియబుల్‌ను కాన్ఫిగర్ చేయడానికి SerpAPIWrapper() పద్ధతిని ఉపయోగించండి మరియు ఏజెంట్‌కు అన్ని పనులను చేయడానికి అవసరమైన సాధనాలను సెట్ చేయండి:

llm = OpenAI ( ఉష్ణోగ్రత = 0 )
వెతకండి = SerpAPIWrapper ( )
ఉపకరణాలు = [
సాధనం (
పేరు = 'ఇంటర్మీడియట్ సమాధానం' ,
ఫంక్ = వెతకండి. పరుగు ,
వివరణ = 'మీరు శోధనతో అడగవలసినప్పుడు ఉపయోగకరంగా ఉంటుంది' ,
)
]

దశ 5: LangChain వ్యక్తీకరణ భాషను ఉపయోగించడం

ప్రాంప్ట్ వేరియబుల్‌లో మోడల్‌ను లోడ్ చేయడం ద్వారా లాంగ్‌చెయిన్ ఎక్స్‌ప్రెషన్ లాంగ్వేజ్ (LCEL) ఉపయోగించి ఏజెంట్‌ను కాన్ఫిగర్ చేయడం ప్రారంభించడం:

ప్రాంప్ట్ = హబ్. లాగండి ( 'hwchase17/self-ask-with-search' )

వచనాన్ని ఉత్పత్తి చేయడాన్ని ఆపివేయడానికి మరియు ప్రత్యుత్తరాల పొడవును నియంత్రించడానికి అమలు చేయగల మరొక వేరియబుల్‌ను నిర్వచించండి:

llm_with_stop = llm కట్టు ( ఆపండి = [ ' \n ఇంటర్మీడియట్ సమాధానం:' ] )

ఇప్పుడు, ప్రశ్నలకు ప్రతిస్పందనలను రూపొందించడానికి ఈవెంట్-ఆధారిత సర్వర్‌లెస్ ప్లాట్‌ఫారమ్ అయిన Lambdaని ఉపయోగించి ఏజెంట్లను కాన్ఫిగర్ చేయండి. అలాగే, ముందుగా కాన్ఫిగర్ చేసిన భాగాలను ఉపయోగించి ఆప్టిమైజ్ చేసిన ఫలితాలను పొందడానికి మోడల్‌కు శిక్షణ ఇవ్వడానికి మరియు పరీక్షించడానికి అవసరమైన దశలను కాన్ఫిగర్ చేయండి:

ఏజెంట్ = {
'ఇన్‌పుట్' : లాంబ్డా x: x [ 'ఇన్‌పుట్' ] ,
'agent_scratchpad' : లాంబ్డా x: format_log_to_str (
x [ 'ఇంటర్మీడియట్_స్టెప్స్' ] ,
పరిశీలన_ఉపసర్గ = ' \n ఇంటర్మీడియట్ సమాధానం: ' ,
llm_ఉపసర్గ = '' ,
) ,
} | ప్రాంప్ట్ | llm_విత్_స్టాప్ | SelfAskOutputParser ( )

దశ 6: ఏజెంట్ ఎగ్జిక్యూటర్‌ని కాన్ఫిగర్ చేయడం

పద్ధతిని పరీక్షించే ముందు, ఏజెంట్ ప్రతిస్పందించేలా చేయడానికి లాంగ్‌చెయిన్ నుండి ఏజెంట్ ఎగ్జిక్యూటర్ లైబ్రరీని దిగుమతి చేయండి:

నుండి లాంగ్చైన్. ఏజెంట్లు దిగుమతి ఏజెంట్ ఎగ్జిక్యూటర్

AgentExecutor() పద్ధతిని కాల్ చేయడం ద్వారా మరియు భాగాలను దాని వాదనలుగా ఉపయోగించడం ద్వారా agent_executor వేరియబుల్‌ను నిర్వచించండి:

ఏజెంట్_ఎగ్జిక్యూటర్ = ఏజెంట్ ఎగ్జిక్యూటర్ ( ఏజెంట్ = ఏజెంట్ , ఉపకరణాలు = ఉపకరణాలు , మాటలతో కూడిన = నిజమే )

దశ 7: ఏజెంట్‌ను అమలు చేయడం

ఏజెంట్ ఎగ్జిక్యూటర్ కాన్ఫిగర్ చేయబడిన తర్వాత, ఇన్‌పుట్ వేరియబుల్‌లో ప్రశ్న/ప్రాంప్ట్ అందించడం ద్వారా దాన్ని పరీక్షించండి:

ఏజెంట్_ఎగ్జిక్యూటర్. సహాయం కోరు ( { 'ఇన్‌పుట్' : 'పురుషుల U.S. ఓపెన్ ఛాంపియన్ ఎవరు' } )

పై కోడ్‌ని అమలు చేయడం వలన అవుట్‌పుట్‌లో US ఓపెన్ ఛాంపియన్ పేరుతో ప్రతిస్పందించారు అంటే డొమినిక్ థీమ్:

దశ 8: స్వీయ-అడిగే ఏజెంట్‌ని ఉపయోగించడం

ఏజెంట్ నుండి ప్రతిస్పందన పొందిన తర్వాత, ఉపయోగించండి SELF_ASK_WITH_SEARCH రన్() పద్ధతిలో ప్రశ్నతో ఏజెంట్:

సెర్చ్‌తో_సెల్ఫ్_అడగండి = ప్రారంభించు_ఏజెంట్ (
ఉపకరణాలు , llm , ఏజెంట్ = ఏజెంట్ రకం. SELF_ASK_WITH_SEARCH , మాటలతో కూడిన = నిజమే
)
సెర్చ్‌తో_సెల్ఫ్_అడగండి. పరుగు (
'యుఎస్ ఓపెన్ వరల్డ్ ఛాంపియన్ డొమినిక్ థీమ్ స్వస్థలం ఏమిటి'
)

కింది స్క్రీన్‌షాట్ స్వీయ-అడుగు ఏజెంట్ డేటాసెట్ నుండి ప్రతి ముఖ్యమైన పదం గురించి సమాచారాన్ని సంగ్రహిస్తుంది. ఇది ప్రశ్నకు సంబంధించిన మొత్తం సమాచారాన్ని సేకరించి, ప్రశ్నలను అర్థం చేసుకున్న తర్వాత, అది కేవలం సమాధానాన్ని రూపొందిస్తుంది. ఏజెంట్ స్వయంగా అడిగే ప్రశ్నలు:

డొమినిక్ థీమ్ ఎవరు?
డొమినిక్ థీమ్ స్వస్థలం ఏది?

ఈ ప్రశ్నలకు సమాధానాలు పొందిన తర్వాత, ఏజెంట్ అసలు ప్రశ్నకు సమాధానాన్ని రూపొందించారు, ఇది “ వీనర్ న్యూస్టాడ్ట్, ఆస్ట్రియా ”:

LangChain ఫ్రేమ్‌వర్క్‌ని ఉపయోగించి శోధన గొలుసుతో స్వీయ-అడుగును అమలు చేసే ప్రక్రియ గురించి అంతే.

ముగింపు

LangChainలో శోధనతో స్వీయ-అడుగును అమలు చేయడానికి, ఏజెంట్ నుండి ఫలితాలను పొందడానికి Google-శోధన-ఫలితాలు వంటి అవసరమైన మాడ్యూల్‌లను ఇన్‌స్టాల్ చేయండి. ఆ తర్వాత, ప్రక్రియను ప్రారంభించడానికి OpenAI మరియు SerpAPi ఖాతాల నుండి API కీలను ఉపయోగించి పర్యావరణాన్ని సెటప్ చేయండి. ఏజెంట్‌ను కాన్ఫిగర్ చేయండి మరియు AgentExecutor() పద్ధతిని ఉపయోగించి పరీక్షించడానికి స్వీయ-అడుగు మోడల్‌తో మోడల్‌ను రూపొందించండి.

సెర్చ్ చైన్‌తో సెల్ఫ్-అస్క్‌ని ఎలా అమలు చేయాలి?