כיצד ליישם את ההיגיון של ReAct באמצעות סוכן ב-LangChain?

ה ' לְהָגִיב ' הוא השילוב של שלבי סיבה ופעולה כדי לשפר את הביצועים של מודל השפה כ' מִחָדָשׁ ' מתייחס להיגיון ו' פעולה ' לפעולה. היגיון של ReAct נחשב לרוב למוטב ביותר לבניית ה-LLMs או הצ'אטבוטים להבנה ויצירת טקסט. הסוכן הוא מקבל ההחלטות שמחליט אילו פעולות לבצע ובאיזה סדר יבוצעו.

כדי ללמוד את תהליך הטמעת הלוגיקה של ReAct באמצעות סוכן ב-LangChain, פשוט עברו על המדריך הבא:

שלב 1: התקנת מסגרות

קודם כל, התקן את LangChain כדי להתחיל בתהליך של הטמעת לוגיקה של ReAct:

pip להתקין langchain

התקן את מודול google-search-results כדי לקבל את התלות לבניית הסוכן שיכול לקבל את תוצאות החיפוש מ- google:

pip התקן את openai google-search-results

לאחר מכן, התקן את מודולי OpenAI שניתן להשתמש בהם כדי לטעון את דגמי השפה הגדולים או ה-LLMs ליישום לוגיקה של ReAct:

pip להתקין openai

לאחר קבלת כל המודולים הנדרשים, פשוט הגדר את סביבת OpenAI לבניית LLM ו סביבת SerpAPI לשימוש בסוכן במודל:

יְבוּא אתה

יְבוּא getpass

אתה . בְּעֵרֶך [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'מפתח API של OpenAI:' )

אתה . בְּעֵרֶך [ 'SERPAPI_API_KEY' ] = getpass . getpass ( 'מפתח API של Serpapi:' )

שלב 2: טעינת מודל שפה

השלב הבא הוא טעינת דגמי השפה על ידי ייבוא הספריות הנדרשות באמצעות מסגרת LangChain:

מ langchain. סוכנים יְבוּא load_tools

מ langchain. סוכנים יְבוּא initialize_agent

מ langchain. סוכנים יְבוּא AgentType

מ langchain. llms יְבוּא OpenAI

השתמש בשיטת OpenAI() כדי לבנות את מודל השפה (llm) ולאחר מכן הגדר את הכלים עבור הסוכנים באמצעות SerpAPI:

llm = OpenAI ( טֶמפֶּרָטוּרָה = 0 )

כלים = load_tools ( [ 'סרפאפי' , 'ללמ-מתמטיקה' ] , llm = llm )

שיטה 1: שימוש בשפת ביטוי LandChain

LCEL הוא תהליך של שילוב או חיבור של שרשראות יחד תוך בניית מודלים לשפות ב-LangChain. התחל את התהליך על ידי התקנת LangChainHub כדי לקבל את התלות שלו לבנייה ושימוש בלוגיקה של ReAct עם סוכנים ב-LangChain:

pip להתקין langchainhub

ייבוא הספריות מה-LangChain כמו ReActSingleInputOutputParser כדי לבנות את המודל שיכול להשתמש במודל ReAct:

מ langchain. כלים . לְדַקלֵם יְבוּא render_text_description

מ langchain. סוכנים . output_parsers יְבוּא ReActSingleInputOutputParser

מ langchain. סוכנים . format_scratchpad יְבוּא format_log_to_str

מ langchain יְבוּא רכזת

טען את מודל השפה כדי לעצב את הלוגיקה של ReAct באמצעות שיטת pull() ואחסן אותו במשתנה ההנחיה. הגדר כמה כלים שניתן להשתמש בהם כדי ליישם את ההיגיון במערך הנתונים הנטען כדי ליישם את עבודתו עם סוכן:

מיידי = רכזת. מְשׁוֹך ( 'hwchase17/react' )

מיידי = מיידי. חלקי (

כלים = render_text_description ( כלים ) ,

כלי_שמות = ',' . לְהִצְטַרֵף ( [ ט. שֵׁם ל ט ב כלים ] ) ,

)

סוכן בניין

כעת, הגדר את הסוכן והכלים שלו על ידי שילובו עם מודל השפה שנטען בשלב 2 של מדריך זה:

llm_with_stop = llm. לִקְשׁוֹר ( תפסיק = [ ' \n תַצְפִּית' ] )

הגדר משתנה סוכן כדי לספק את הארגומנטים והכלים להגדרת הסוכן שמסבירים את פעולתו. החלקים שהוגדרו בעבר כמו llm_with_stop ושיטת ReActSingleInputOutputParser() משולבים עם הסוכן:

סוֹכֵן = {

'קֶלֶט' : למבדה x: x [ 'קֶלֶט' ] ,

'agent_scratchpad' : למבדה x: format_log_to_str ( איקס [ 'צעדי_ביניים' ] )

} | הנחיה | llm_with_stop | ReActSingleInputOutputParser ( )

קבל את ספריית AgentExecutor והגדר את השיטה שלה באמצעות ארגומנטים כמו סוכן, כלים ומילולי כדי לקבל פלט קריא יותר:

מ langchain. סוכנים יְבוּא AgentExecutor

agent_executor = AgentExecutor ( סוֹכֵן = סוֹכֵן , כלים = כלים , מִלוּלִי = נָכוֹן )

הפעל את שיטת agent_executor() עם שאילתת המחרוזת כקלט שתפעיל את הסוכן לחלץ את הפלט:

agent_executor. לעורר ( { 'קֶלֶט' : 'מי החברה של ליאו דיקפריו' } )

תְפוּקָה

צילום המסך הבא מציג שהסוכן חילץ את המידע באמצעות הלוגיקה של ReAct ויצר את הטקסט בשפה טבעית:

שיטה 2: שימוש ב- ZeroShotReactAgent

ניתן ליישם את הלוגיקה של ReAct גם על ידי שימוש בסוכן אחר כמו ZeroShotReactAgent תוך הגדרת המשתנה agent_executor. לאחר מכן, פשוט קרא למשתנה agent_executor עם השאלה כקלט להפעלת הסוכן:

agent_executor = initialize_agent ( כלים , llm , סוֹכֵן = AgentType. ZERO_SHOT_REACT_DESCRIPTION , מִלוּלִי = נָכוֹן )

agent_executor. לעורר ( { 'קֶלֶט' : 'מהו גיל החברה של ליאו דיקפריו שהועלה לעוצמה של 0.21' } )

תְפוּקָה

הסוכן חילץ את המידע על סמך הקלט שנשאל בעת הפעלת ה-agent_executor:

שיטה 3: שימוש במודלים של צ'אט

תהליך נוסף שניתן להשתמש בו כדי ליישם את הלוגיקה של ReAct על ידי שימוש במודלים של הצ'אט לאחר ייבוא ספריית ChatOpenAI:

מ langchain. chat_models יְבוּא ChatOpenAI

בנה את מודל הצ'אט באמצעות שיטת ChatOpenAI() עם ערך הטמפרטורה שווה ל-0 שיכול לשלוט באקראיות בתוצאות המודל:

chat_model = ChatOpenAI ( טֶמפֶּרָטוּרָה = 0 )

טען את המודל שבו המשתמש יכול ליישם את הלוגיקה של ReAct כדי לאחסן אותו במשתנה ההנחיה ולהגדיר את הכלים לשימוש בתהליך:

מיידי = רכזת. מְשׁוֹך ( 'hwchase17/react-json' )

מיידי = מיידי. חלקי (

כלים = render_text_description ( כלים ) ,

כלי_שמות = ',' . לְהִצְטַרֵף ( [ ט. שֵׁם ל ט ב כלים ] ) ,

)

בניית הסוכן

השתמש במודל הצ'אט כדי לאחסן את התצפיות או ההודעות האחרונות כאשר המודל מפסיק להפיק את הטקסט:

chat_model_with_stop = chat_model. לִקְשׁוֹר ( תפסיק = [ ' \n תַצְפִּית' ] )

קבל את ספריית ReActJsonSingleInputOutputParser כדי ליישם את הלוגיקה של ReAct ולהפיק את התוצאות בפורמט JSON:

מ langchain. סוכנים . output_parsers יְבוּא ReActJsonSingleInputOutputParser

בנה והגדר את הסוכן באמצעות המשתנה והשיטה chat_model כדי להפיק תוצאות על ידי קריאה לסוכן:

סוֹכֵן = {

'קֶלֶט' : למבדה x: x [ 'קֶלֶט' ] ,

'agent_scratchpad' : למבדה x: format_log_to_str ( איקס [ 'צעדי_ביניים' ] )

} | הנחיה | chat_model_with_stop | ReActJsonSingleInputOutputParser ( )

הגדר את ה-agent_executor והפעל אותו כדי לקבל את התוצאות על סמך השאילתה שסופקה במשתנה הקלט:

agent_executor = AgentExecutor ( סוֹכֵן = סוֹכֵן , כלים = כלים , מִלוּלִי = נָכוֹן )

agent_executor. לעורר ( { 'קֶלֶט' : 'מהו גיל החברה של ליאו דיקפריו שהועלה לעוצמה של 0.21' } )

תְפוּקָה

הסוכן חילץ את הפלט כפי שמוצג בצילום המסך הבא:

שיטה 4: שימוש ב-ChatZeroShotReactAgent

שינוי הערך של הסוכן יכול לשמש גם כדי ליישם את הלוגיקה של ReAct עם המסגרת של LangChain:

סוֹכֵן = initialize_agent ( כלים , chat_model , סוֹכֵן = AgentType. CHAT_ZERO_SHOT_REACT_DESCRIPTION , מִלוּלִי = נָכוֹן )

סוֹכֵן. לָרוּץ ( 'מהו גיל החברה של ליאו דיקפריו שהועלה לעוצמה של 0.21' )

תְפוּקָה

מבנה הפלט מכיל מידע מפורט על פעולתו של הסוכן מהאסימונים והמודל המשמשים לחילוץ המידע:

זה הכל לגבי תהליך הטמעת הלוגיקה של ReAct באמצעות סוכן ב-LangChain.

סיכום

כדי ליישם את הלוגיקה של ReAct עם סוכן המשתמש במסגרת LangChain, התקן מודולים כמו google-search-results כדי להגדיר את הסוכן. לאחר מכן, הגדר את הסביבה באמצעות אישורי OpenAI ו-SerpAPI מהחשבונות שלהם כדי להתחיל להשתמש במודל. ניתן ליישם את ההיגיון של ReAct באמצעות מודלים של LCEL וצ'אט עם מספר סוכנים המוצעים על ידי מודול LangChain. מדריך זה הרחיב על יישום הלוגיקה של ReAct באמצעות הסוכן ב-LangChain.

כיצד ליישם את ההיגיון של ReAct באמצעות סוכן ב-LangChain?

מתאר מהיר