قدرت Langchain را تجربه کنید: نسل بعدی یادگیری زبان

LangChain یک چارچوب خلاقانه برای ایجاد برنامه های کاربردی مبتنی بر زبان است. LangChain، با رویکرد قابل تنظیم و ویژگی‌های یکپارچه‌سازی گسترده، سطح جدیدی از کنترل و انعطاف‌پذیری را در هنگام استفاده از مدل‌های زبان به توسعه‌دهندگان می‌دهد.

LangChain

LangChain چارچوبی برای ایجاد برنامه‌های مبتنی بر زبان است. قدرتمندترین و متمایزترین برنامه ها نه تنها از یک API برای دسترسی به یک مدل زبان استفاده می کنند، بلکه:

• آگاه باشید: یک مدل زبان را به منابع داده اضافی متصل کنید.
• عامل باشید: به یک مدل زبان اجازه دهید با محیط اطراف خود تعامل داشته باشد.

چارچوب LangChain با در نظر گرفتن اصول بالا طراحی شده است. این بخش اختصاصی پایتون از اسناد است.

اعلام:

در سطح بالایی، درخواست‌ها بر اساس موارد استفاده در دایرکتوری اعلان‌ها سازمان‌دهی می‌شوند. برای بارگیری یک درخواست در LangChain، باید از قطعه کد زیر استفاده کنید:

از langchain.prompts وارد کردن load_prompt

prompt = load_prompt('lc://prompts/path/to/file.json')

زنجیره

زنجیره‌ها فراتر از یک تماس LLM منفرد گسترش می‌یابند و دنباله‌ای از تماس‌ها (به یک LLM یا ابزار دیگر) را شامل می‌شوند. LangChain یک رابط زنجیره ای استاندارد، اتصالات متعدد با ابزارهای دیگر و زنجیره های سرتاسر برای برنامه های معمولی ارائه می دهد.

زنجیره‌ها بر اساس موارد استفاده در فهرست chains در سطح بالایی سازمان‌دهی می‌شوند. از قطعه کد زیر برای بارگیری یک زنجیره در LangChain استفاده کنید:

از langchain.chains وارد کردن load_chain

chain = load_chain ('lc://chains/path/to/file.json')

نمایندگان

آقایان شامل یک LLM هستند که در مورد اقداماتی که باید انجام دهند قضاوت می کند، آن عمل را انجام می دهد، یک مشاهده را مشاهده می کند و این فرآیند را تا زمانی که کامل می شود تکرار می کند. LangChain یک رابط عامل استاندارد، مجموعه‌ای از عامل‌ها و نمونه‌هایی از عوامل سرتاسر ارائه می‌کند.

نمایندگان با استفاده از case در فهرست agents در سطح بالایی سازماندهی می‌شوند. از قطعه کد زیر برای بارگیری یک عامل در LangChain استفاده کنید:

از langchain.agents import initialize_agent

llm = ...
ابزار = ...

agent = initialize_agent(tools, llm, agent="lc://agents/self-ask-with-search/agent.json")

نصب

برای شروع، LangChain را با دستور زیر نصب کنید:

langchain نصب پیپ
# یا
conda نصب langchain -c conda-forge

تنظیم محیط

هنگام استفاده از LangChain اغلب به یکپارچه‌سازی با یک یا چند ارائه‌دهنده مدل، ذخیره‌سازی داده‌ها، APIها و غیره نیاز است.

از آنجا که در این مثال از APIهای OpenAI استفاده خواهیم کرد، ابتدا باید SDK آنها را نصب کنیم:

openai نصب پیپ

سپس باید متغیر محیطی را در ترمینال تنظیم کنیم.

صادر کردن OPENAI_API_KEY="..."

از طرف دیگر، می توانید این کار را از داخل نوت بوک Jupyter (یا اسکریپت پایتون) انجام دهید:

وارد کردن سیستم عامل
os.environ["OPENAI_API_KEY"] = "..."

ساخت یک مدل زبان برنامه کاربردی: LLM

اکنون که LangChain را نصب کرده ایم و محیط خود را پیکربندی کرده ایم، می توانیم توسعه برنامه مدل زبان خود را شروع کنیم.

LangChain تعدادی ماژول دارد که ممکن است برای ایجاد برنامه های کاربردی مدل زبان استفاده شوند. ماژول‌ها را می‌توان برای ساخت برنامه‌های پیچیده‌تر ادغام کرد یا به تنهایی برای ساخت برنامه‌های اساسی استفاده کرد.

LLM: دریافت پیش بینی از یک مدل زبان

اساسی ترین مؤلفه ساختمان LangChain فراخوانی یک LLM بر روی برخی ورودی است. بیایید یک مثال ساده از چگونگی دستیابی به این را مرور کنیم. فرض کنید ما در حال ایجاد سرویسی هستیم که نام شرکت را بر اساس آنچه شرکت تولید می کند ایجاد می کند.

برای رسیدن به این هدف، ابتدا باید بسته بندی LLM را وارد کنیم.

از langchain.llms واردات OpenAI

سپس می‌توانیم wrapper را با هر آرگومان مقداردهی کنیم. در این مثال، احتمالاً می‌خواهیم خروجی‌ها تصادفی‌تر باشند، بنابراین آن را با دمای بالا مقداردهی اولیه می‌کنیم.

llm = OpenAI(temperature=0.9)

اکنون می‌توانیم آن را در یک ورودی فراخوانی کنیم!

text = "نام شرکتی خوب برای شرکتی که جوراب های رنگارنگ تولید می کند، چیست؟"
print(llm(text))

سرگرم کننده

الگوهای درخواست: اعلان های LLM را مدیریت کنید.

تماس با یک LLM شروع خوبی است، اما فقط شروع است. وقتی از یک LLM در یک برنامه استفاده می کنید، معمولا ورودی کاربر را مستقیماً به LLM نمی دهید. در عوض، احتمالاً در حال جمع‌آوری ورودی کاربر و ایجاد یک درخواست هستید، که سپس آن را به LLM ارسال می‌کنید.

در مثال آخر، برای مثال، متنی که ما در آن ارائه کردیم، برای درخواست نام برای شرکتی که جوراب های رنگارنگ می فروشد، کدگذاری شده بود. در این سرویس فرضی، ما می‌خواهیم فقط ورودی کاربر را که توضیح می‌دهد شرکت انجام می‌دهد، بگیریم و درخواست را با آن اطلاعات قالب‌بندی کنیم.

این کار با LangChain ساده است!

بیایید با الگوی درخواست شروع کنیم:

از langchain.prompts وارد PromptTemplate

prompt = PromptTemplate(
    input_variables=["محصول"]،
    template="نام خوبی برای شرکتی که {product} را تولید می کند چیست؟"
)

بیایید ببینیم این چگونه کار می کند! برای قالب‌بندی آن می‌توانیم روش  .format را فراخوانی کنیم.

print(prompt.format(product="colorful socks"))

نام خوبی برای شرکتی که جوراب های رنگارنگ تولید می کند چیست؟

زنجیره ها: ترکیب LLM ها و درخواست ها در گردش های کاری چند مرحله ای

تا کنون، ما فقط از PromptTemplate و LLM اولیه به تنهایی استفاده می کردیم. البته، یک برنامه واقعی ترکیبی از موارد اولیه است تا یک برنامه واحد.

در LangChain، یک زنجیره از پیوندهایی ساخته شده است که می توانند ابتدایی باشند مانند LLM یا زنجیره های دیگر.

یک زنجیره LLMC ابتدایی ترین نوع زنجیره است که از یک الگوی اعلان و یک LLM تشکیل شده است.

با گسترش مثال قبلی، می‌توانیم یک LLMChain بسازیم که ورودی کاربر را می‌پذیرد، آن را با یک الگوی Prompt آماده می‌کند و سپس نتیجه پردازش شده را به یک LLM ارسال می‌کند.

از langchain.prompts وارد PromptTemplate
از langchain.llms واردات OpenAI

llm = OpenAI (دما = 0.9)
prompt = PromptTemplate(
    input_variables=["محصول"]،
    template="نام خوبی برای شرکتی که {product} را تولید می کند چیست؟"
)

اکنون می‌توانیم یک زنجیره بسیار ساده ایجاد کنیم که ورودی کاربر را دریافت می‌کند، درخواست را با آن قالب‌بندی می‌کند و سپس آن را به LLM ارسال می‌کند:

از langchain.chains واردات LLMChain
chain = LLMCchain(llm=llm, prompt=prompt)

اکنون می‌توانیم آن زنجیره را فقط با مشخص کردن محصول اجرا کنیم!

chain.run("جوراب های رنگارنگ")
# -> 'nnSocktastic!'

اولین زنجیره یک زنجیره LLM است. اگرچه این یکی از انواع ساده‌تر زنجیره‌ها است، اما درک نحوه عملکرد آن شما را برای کار با زنجیره‌های پیچیده‌تر آماده می‌کند.

نمایندگان: به صورت پویا زنجیره‌ها را بر اساس ورودی کاربر فراخوانی می‌کنند

تا کنون، زنجیره‌هایی که ما به آنها نگاه کرده‌ایم به ترتیب از پیش تعیین‌شده اجرا می‌شوند.

یک LLM دیگر توسط نمایندگان برای انتخاب اقدامات انجام شده و به چه ترتیبی استفاده نمی شود. یک عمل ممکن است بررسی خروجی یک ابزار یا بازگشت به کاربر باشد.

هنگامی که به‌طور مناسب از عوامل استفاده شود، ممکن است بسیار قوی باشند. در این آموزش، نحوه استفاده از عوامل با استفاده از ساده‌ترین و بالاترین سطح API را نشان خواهیم داد.

برای بارگیری عوامل، باید مفاهیم زیر را درک کنید:

• ابزار: عملکردی که هدف خاصی را انجام می دهد. این می تواند شامل جستجوی گوگل، جستجوی پایگاه داده، REPL های پایتون و سایر زنجیره ها باشد. رابط ابزار در حال حاضر تابعی است که قرار است یک رشته را به عنوان ورودی بگیرد و یک رشته را به عنوان خروجی برگرداند.
• LLM: مدل زبانی که عامل را هدایت می‌کند.
• عامل: عامل مورد استفاده. این باید یک رشته حاوی نام یک کلاس عامل پشتیبانی باشد. این نوت بوک فقط استفاده از عوامل استاندارد پشتیبانی شده را پوشش می دهد زیرا بر ساده ترین و بالاترین سطح API تمرکز دارد. اگر می‌خواهید یکی از آنها را پیاده‌سازی کنید، به مستندات مربوط به عوامل سفارشی مراجعه کنید.

نمایندگان: برای لیستی از عوامل پشتیبانی شده و مشخصات آنها، به اینجا.

ابزارها: برای فهرستی از ابزارهای از پیش تعریف شده و مشخصات آنها، به اینجا.

برای این مثال، شما همچنین باید بسته SerpAPI Python را نصب کنید.

پیپ نصب google-search-results

و متغیرهای محیطی مناسب را تنظیم کنید.

وارد کردن سیستم عامل
os.environ["SERPAPI_API_KEY"] = "..."

اکنون می توانیم شروع کنیم!

از langchain.agents import load_tools
از langchain.agents واردات initialize_agent
از langchain.agents import AgentType
از langchain.llms واردات OpenAI

# ابتدا، بیایید مدل زبانی را که می‌خواهیم برای کنترل عامل استفاده کنیم، بارگذاری کنیم.
llm = OpenAI (دما = 0)

# بعد، بیایید چند ابزار را برای استفاده بارگذاری کنیم. توجه داشته باشید که ابزار "llm-math" از یک LLM استفاده می کند، بنابراین باید آن را وارد کنیم.
tools = load_tools(["serpapi"، "llm-math"]، llm=llm)


# در نهایت، اجازه دهید یک عامل را با ابزارها، مدل زبان و نوع عاملی که می‌خواهیم استفاده کنیم، مقداردهی اولیه کنیم.
agent = initialize_agent (ابزار، llm، agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION، verbose=True)

# حالا بیایید آن را آزمایش کنیم!
agent.run("دمای بالا در SF دیروز در فارنهایت چقدر بود؟ این عدد به توان 0.023 چقدر است؟")

> ورود به زنجیره جدید AgentExecutor...
 ابتدا باید دما را پیدا کنم، سپس با استفاده از ماشین حساب آن را به توان 0.023 برسانم.
اقدام: جستجو
ورودی اقدام: "دمای بالا در SF دیروز"
مشاهده: دمای سانفرانسیسکو دیروز. حداکثر دما دیروز: 57 درجه فارنهایت (ساعت 1:56 بعد از ظهر) حداقل دما دیروز: 49 درجه فارنهایت (در ساعت 1:56 بامداد) میانگین دما ...
فکر کردم: اکنون دما را دارم، بنابراین می توانم از ماشین حساب استفاده کنم تا آن را به توان 0.023 برسانم.
اکشن: ماشین حساب
ورودی اقدام: 57^.023
مشاهده: پاسخ: 1.0974509573251117

فکر: اکنون پاسخ نهایی را می دانم
پاسخ نهایی: دمای بالا در SF دیروز در فارنهایت به توان 0.023 افزایش یافته است 1.0974509573251117.

> زنجیره تمام شد.

حافظه: افزودن حالت به زنجیره ها و عوامل

همه زنجیره‌ها و عواملی که تاکنون با آنها مواجه شده‌ایم بدون تابعیت بوده‌اند. با این حال، ممکن است بخواهید یک زنجیره یا عامل مفهومی از “حافظه” داشته باشد تا بتواند اطلاعات تعاملات قبلی را به خاطر بسپارد. برای مثال، هنگام طراحی یک ربات چت، می‌خواهید پیام‌های قبلی را به خاطر بسپارد تا بتواند از متن آن برای داشتن مکالمه بهتر استفاده کند. این نوعی “حافظه کوتاه مدت” است. از طرفی پیچیده‌تر، می‌توانید زنجیره‌ای/عاملی را تصور کنید که بخش‌های کلیدی اطلاعات را در طول زمان به خاطر می‌آورد – این نوعی «حافظه بلندمدت» است.

LangChain چندین زنجیره خاص ایجاد شده را فقط برای این منظور فراهم می کند. این نوت‌بوک با استفاده از یکی از آن زنجیره‌ها (ConversationChain) با دو نوع حافظه مختلف راه می‌رود.

به‌طور پیش‌فرض، ConversationChain یک نوع حافظه ساده دارد که همه ورودی‌ها/خروجی‌های قبلی را به خاطر می‌آورد و آنها را به متن ارسالی اضافه می‌کند. بیایید نگاهی به استفاده از این زنجیره بیندازیم (تنظیم verbose=True تا بتوانیم درخواست را ببینیم).

از واردات لانگچین OpenAI، ConversationChain

llm = OpenAI (دما = 0)
گفتگو = ConversationChain (llm=llm، verbose=true)

output = talk.predict(input="سلام!)
چاپ (خروجی)

> ورود به زنجیره جدید...
درخواست بعد از قالب بندی:
گفتگوی زیر یک گفتگوی دوستانه بین یک انسان و یک هوش مصنوعی است. هوش مصنوعی پرحرف است و جزئیات خاصی را از زمینه خود ارائه می دهد. اگر هوش مصنوعی پاسخ سوالی را نداند، به درستی می گوید نمی داند.

گفتگوی فعلی:

انسان: سلام!
هوش مصنوعی:

> زنجیره تمام شده
' سلام! امروز چطوری؟'

output = talk.predict(input="حالم خوب است! فقط با یک هوش مصنوعی مکالمه می کنم. ")
چاپ (خروجی)

> ورود به زنجیره جدید...
درخواست بعد از قالب بندی:
گفتگوی زیر یک گفتگوی دوستانه بین یک انسان و یک هوش مصنوعی است. هوش مصنوعی پرحرف است و جزئیات خاصی را از زمینه خود ارائه می دهد. اگر هوش مصنوعی پاسخ سوالی را نداند، به درستی می گوید نمی داند.

گفتگوی فعلی:

انسان: سلام!
AI: سلام! امروز چطوری؟
انسان: حالم خوبه! فقط در حال مکالمه با یک هوش مصنوعی.
هوش مصنوعی:

> زنجیره تمام شده
"این عالی است! دوست دارید در مورد چه چیزی صحبت کنید؟"

ساخت یک مدل زبان برنامه کاربردی: مدل های چت

به طور مشابه، مدل های مکالمه را می توان به جای LLM ها استفاده کرد. مدل های زبان زیر مجموعه ای از مدل های چت هستند. در حالی که مدل‌های چت از مدل‌های زبانی در پشت صحنه استفاده می‌کنند، رابطی که آنها در معرض نمایش قرار می‌دهند کمی متفاوت است: به جای نمایش یک API «متن در، متن خارج»، رابطی را نشان می‌دهند که «پیام‌های چت» ورودی و خروجی هستند.

از آنجایی که APIهای مدل چت هنوز در مراحل اولیه خود هستند، هنوز در حال تعیین انتزاعات مناسب هستند.

دریافت تکمیل پیام از مدل چت

می‌توانید با ارسال یک یا چند پیام به مدل چت، تکمیل‌های چت را دریافت کنید. پاسخ یک پیام خواهد بود. انواع پیام هایی که در حال حاضر در LangChain پشتیبانی می شوند عبارتند از: AIMessage، HumanMessage، SystemMessage و ChatMessage – Chat Message. یک پارامتر نقش دلخواه را می گیرد. بیشتر اوقات، شما فقط با HumanMessage، AIMessage و SystemMessage سر و کار دارید.

از langchain.chat_models وارد کردن ChatOpenAI
از واردات langchain.schema (
    AIMsage,
    پیام انسانی،
    پیام سیستم
)

چت = ChatOpenAI(دما=0)

می‌توانید با ارسال یک پیام، موارد تکمیلی را دریافت کنید.

چت([HumanMessage(content="این جمله را از انگلیسی به فرانسوی ترجمه کنید. من عاشق برنامه نویسی هستم.")] )
# -> AIMessage(content="J'aime programmer.", extra_kwargs={})

همچنین می‌توانید چندین پیام را برای مدل‌های gpt-3.5-turbo و gpt-4 OpenAI ارسال کنید.

پیام ها = [
    SystemMessage(content="شما دستیار مفیدی هستید که انگلیسی به فرانسوی را ترجمه می کنید.")
    HumanMessage(content="این جمله را از انگلیسی به فرانسوی ترجمه کنید. من عاشق برنامه نویسی هستم.")
]
چت (پیام)
# -> AIMessage(content="J'aime programmer.", extra_kwargs={})

می‌توانید یک گام جلوتر بروید و با استفاده از تولید، مجموعه‌ای از پیام‌ها را تکمیل کنید. این یک LLMResult با یک پارامتر پیام  اضافی برمی‌گرداند:

batch_messages = [
    [
        SystemMessage(content="شما دستیار مفیدی هستید که انگلیسی به فرانسوی را ترجمه می کنید.")
        HumanMessage(content="این جمله را از انگلیسی به فرانسوی ترجمه کنید. من عاشق برنامه نویسی هستم.")
    ]،
    [
        SystemMessage(content="شما دستیار مفیدی هستید که انگلیسی به فرانسوی را ترجمه می کنید.")
        HumanMessage(content="این جمله را از انگلیسی به فرانسوی ترجمه کنید. من عاشق هوش مصنوعی هستم.")
    ]،
]
نتیجه = chat.generate(batch_messages)
نتیجه
# -> LLMResult(generations=[[ChatGeneration(text="J'aime programmer.", Generation_info=None, message=AIMessage(content="J'aime programmer.", extra_kwargs={}))]، [Chat Generation( text="J'aime l'intelligence artificielle.", Generation_info=None, message=AIMessage(content="J'aime l'intelligence artificielle.", extra_kwargs={}))]], llm_output={'token_usage': {'prompt_tokens': 71, 'completion_tokens': 18, 'total_tokens': 89}})

شما می توانید مواردی مانند استفاده از رمز را از این LLMResult بازیابی کنید:

result.llm_output['token_usage']
# -> {'prompt_tokens': 71, 'completion_tokens': 18, 'total_tokens': 89}

الگوهای درخواست چت

شبیه به LLM، می‌توانید با استفاده از یک MessagePromptTemplate از الگوسازی استفاده کنید. می‌توانید یک ChatPromptTemplate از یک یا چند MessagePromptTemplate بسازید. می‌توانید از ChatPromptTemplate format_prompt  استفاده کنید – این یک PromptValue را برمی‌گرداند که می‌توانید آن را به یک رشته یا پیام تبدیل کنید. بسته به اینکه می‌خواهید از مقدار قالب‌بندی شده به عنوان ورودی مدل llm یا چت استفاده کنید، شیء است.

برای راحتی، یک روش from_template روی الگو وجود دارد. اگر بخواهید از این الگو استفاده کنید، این شکلی است:

از langchain.chat_models وارد کردن ChatOpenAI
از واردات langchain.prompts.chat (
    ChatPromptTemplate،
    SystemMessagePromptTemplate،
    HumanMessagePromptTemplate،
)

چت = ChatOpenAI (دما = 0)

template = "شما دستیار مفیدی هستید که {input_language} را به {output_language} ترجمه می کنید."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])

# تکمیل چت را از پیام های قالب بندی شده دریافت کنید
chat(chat_prompt.format_prompt(input_language="انگلیسی", output_language="فرانسوی"، text="من عاشق برنامه نویسی هستم.").to_messages())
# -> AIMessage(content="J'aime programmer.", extra_kwargs={})

زنجیره‌ها با مدل‌های چت

 LLMCchain  که در بخش بالا مورد بحث قرار گرفت می‌تواند با مدل‌های چت نیز استفاده شود:

از langchain.chat_models وارد کردن ChatOpenAI
از لانگ چین واردات LLMCchain
از واردات langchain.prompts.chat (
    ChatPromptTemplate،
    SystemMessagePromptTemplate،
    HumanMessagePromptTemplate،
)

چت = ChatOpenAI (دما = 0)

template = "شما دستیار مفیدی هستید که {input_language} را به {output_language} ترجمه می کنید."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])

chain = LLMChain (llm=chat, prompt=chat_prompt)
chain.run(input_language="انگلیسی", output_language="فرانسوی"، text="من عاشق برنامه نویسی هستم.")
# -> "برنامه نویس J'aime."

نمایندگان با مدل‌های چت

نمایندگان همچنین می توانند با مدل های چت استفاده شوند. می توانید یکی را با استفاده از AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION به عنوان نوع عامل مقداردهی اولیه کنید.

از langchain.agents import load_tools
از langchain.agents واردات initialize_agent
از langchain.agents import AgentType
از langchain.chat_models ChatOpenAI را وارد کنید
از langchain.llms واردات OpenAI

# ابتدا، بیایید مدل زبانی را که می‌خواهیم برای کنترل عامل استفاده کنیم، بارگذاری کنیم.
چت = ChatOpenAI (دما = 0)

# بعد، بیایید چند ابزار را برای استفاده بارگذاری کنیم. توجه داشته باشید که ابزار "llm-math" از یک LLM استفاده می کند، بنابراین باید آن را وارد کنیم.
llm = OpenAI (دما = 0)
tools = load_tools(["serpapi"، "llm-math"]، llm=llm)


# در نهایت، اجازه دهید یک عامل را با ابزارها، مدل زبان و نوع عاملی که می‌خواهیم استفاده کنیم، مقداردهی اولیه کنیم.
agent = initialize_agent(ابزارها، چت، agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION، verbose=True)

# حالا بیایید آن را آزمایش کنیم!
agent.run("دوست پسر اولیویا وایلد کیست؟ سن فعلی او تا 0.23 چقدر است؟")

> ورود به زنجیره AgentExecutor جدید...
فکر: من باید از یک موتور جستجو برای یافتن دوست پسر اولیویا وایلد و یک ماشین حساب استفاده کنم تا سن او را به توان 0.23 برسانم.
عمل:
{
  "عمل": "جستجو"،
  "action_input": "دوست پسر اولیویا وایلد"
}

مشاهده: رابطه سودیکیس و وایلد در نوامبر 2020 به پایان رسید. وایلد در حالی که در CinemaCon 2022 در حال ارائه نگران نباش عزیزم در CinemaCon 2022 بود، به طور علنی اسناد دادگاه را در مورد حضانت فرزند دریافت کرد. در ژانویه 2021، وایلد پس از ملاقات در حین فیلمبرداری با هری استایلز، خواننده را آغاز کرد. نگران نباش عزیزم
فکر: من باید از یک موتور جستجو برای یافتن سن فعلی هری استایلز استفاده کنم.
عمل:
{
  "عمل": "جستجو"،
  "action_input": "سن هری استایلز"
}

مشاهده: 29 سال
فکر: اکنون باید 29 را به توان 0.23 محاسبه کنم.
عمل:
{
  "عمل": "ماشین حساب"،
  "action_input": "29^0.23"
}

مشاهده: پاسخ: 2.169459462491557

فکر: اکنون پاسخ نهایی را می دانم.
پاسخ نهایی: 2.169459462491557

> زنجیره تمام شده
'2.169459462491557'

حافظه: افزودن حالت به زنجیره ها و عوامل

حافظه ممکن است با زنجیره ها و عواملی که با استفاده از مدل های مکالمه مقداردهی اولیه شده اند استفاده شود. تفاوت اصلی بین این و Memory for LLM در این است که به جای متراکم کردن همه پیام‌های قبلی در یک رشته، ممکن است آنها را به عنوان شی حافظه متمایز خود ذخیره کنیم.

از واردات langchain.prompts (
    ChatPromptTemplate،
    MessagesPlaceholder,
    SystemMessagePromptTemplate،
    HumanMessagePromptTemplate
)
از langchain.chains وارد ConversationChain
از langchain.chat_models ChatOpenAI را وارد کنید
از langchain.memory import ConversationBufferMemory

prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template("مکالمه زیر یک مکالمه دوستانه بین یک انسان و یک هوش مصنوعی است. هوش مصنوعی پرحرف است و جزئیات خاصی را از زمینه خود ارائه می دهد. اگر هوش مصنوعی پاسخ یک سوال را نداند، به درستی می گوید که نمی داند. می دانم.")،
    MessagesPlaceholder(variable_name="history")،
    HumanMessagePromptTemplate.from_template("{input}")
])

llm = ChatOpenAI (دما = 0)
حافظه = ConversationBufferMemory(return_messages=True)
مکالمه = زنجیره گفتگو (حافظه = حافظه، اعلان = اعلان، llm = llm)

گفتگو.predict(input="سلام!)
# -> 'سلام! امروز چگونه می توانم به شما کمک کنم؟


گفتگو.predict(input="حالم خوب است! فقط با یک هوش مصنوعی مکالمه می کنم.")
# -> "به نظر سرگرم کننده است! من خوشحالم که با شما چت می کنم. آیا چیز خاصی وجود دارد که بخواهید در مورد آن صحبت کنید؟"

گفتگو.predict(input="درباره خودت به من بگو.")
# -> "مطمئنا! من یک مدل زبان هوش مصنوعی هستم که توسط OpenAI ایجاد شده است. من روی مجموعه داده بزرگی از متن از اینترنت آموزش دیدم که به من امکان می دهد زبانی شبیه انسان را بفهمم و تولید کنم. می توانم به سوالات پاسخ دهم، اطلاعات ارائه کنم و حتی مکالماتی مانند این داشته باشید. آیا چیز دیگری وجود دارد که بخواهید درباره من بدانید؟"

این مقاله به شما کمک می کند تا در مورد LangChain بیاموزید. ما اطمینان داریم که برای شما مفید بوده است. لطفاً نظرات و انتقادات خود را در بخش نظرات زیر به اشتراک بگذارید.