LangChain არის უახლესი და ძლიერი ინსტრუმენტი, რომელიც შემუშავებულია დიდი ენობრივი მოდელების (LLMs) ძალაუფლების გამოსაყენებლად.
ამ LLM-ებს აქვთ შესანიშნავი შესაძლებლობები და შეუძლიათ ეფექტურად გაუმკლავდნენ ამოცანების ფართო სპექტრს. თუმცა, მნიშვნელოვანია აღინიშნოს, რომ მათი სიძლიერე მდგომარეობს მათ ზოგად ბუნებაში და არა სიღრმისეულ დომენში. მისი პოპულარობა სწრაფად გაიზარდა GPT-4-ის დანერგვის შემდეგ.
მიუხედავად იმისა, რომ LLM-ები გამოირჩევიან სხვადასხვა დავალებების შესრულებაში, მათ შეიძლება შეექმნათ შეზღუდვები, როდესაც საქმე ეხება კონკრეტული პასუხების მიწოდებას ან ამოცანებს, რომლებიც საჭიროებენ დომენის ღრმა ცოდნას. განვიხილოთ, მაგალითად, LLM-ის გამოყენება კითხვებზე პასუხის გასაცემად ან დავალებების შესასრულებლად სპეციალიზებულ სფეროებში, როგორიცაა მედიცინა ან სამართალი.
მიუხედავად იმისა, რომ LLM, რა თქმა უნდა, შეუძლია უპასუხოს ზოგად შეკითხვებს ამ სფეროების შესახებ, მას შეიძლება გაუჭირდეს უფრო დეტალური ან ნიუანსირებული პასუხების შეთავაზება, რომლებიც საჭიროებენ სპეციალიზებულ ცოდნას ან გამოცდილებას.
ეს იმიტომ ხდება, რომ LLM-ები გადიან ტრენინგს სხვადასხვა წყაროდან მიღებული ტექსტური მონაცემების დიდ რაოდენობაზე, რაც მათ საშუალებას აძლევს ისწავლონ შაბლონები, გააცნობიერონ კონტექსტი და შექმნან თანმიმდევრული პასუხები. თუმცა, მათი ტრენინგი, როგორც წესი, არ გულისხმობს დომენის სპეციფიკურ ან სპეციალიზებულ ცოდნის შეძენას ისევე, როგორც ადამიანური ექსპერტები ამ სფეროებში.
ამიტომ, მიუხედავად იმისა, რომ LangChain, LLM-ებთან ერთად, შეიძლება იყოს ფასდაუდებელი ინსტრუმენტი ამოცანების ფართო სპექტრისთვის, მნიშვნელოვანია იმის აღიარება, რომ ღრმა დომენის ექსპერტიზა შეიძლება მაინც იყოს საჭირო გარკვეულ სიტუაციებში. სპეციალიზებული ცოდნის მქონე ადამიანურ ექსპერტებს შეუძლიათ მიაწოდონ საჭირო სიღრმე, ნიუანსური გაგება და კონტექსტის სპეციფიკური შეხედულებები, რაც შეიძლება მხოლოდ LLM-ების შესაძლებლობებს აღემატებოდეს.
ჩვენ გირჩევთ გადახედოთ LangChain-ის დოკუმენტებს ან GitHub საცავი მისი ტიპიური გამოყენების შემთხვევების უფრო საფუძვლიანად გასაგებად. კატეგორიულად რეკომენდებულია ამ ნაკრების უფრო დიდი სურათის მიღება.
Როგორ მუშაობს?
LangChain-ის მიზნისა და მუშაობის გასაგებად, განვიხილოთ პრაქტიკული მაგალითი. ჩვენ ვიცით, რომ GPT-4-ს აქვს შთამბეჭდავი ზოგადი ცოდნა და შეუძლია საიმედო პასუხების გაცემა კითხვებზე ფართო სპექტრზე.
თუმცა, რა მოხდება, თუ გვსურს კონკრეტული ინფორმაცია ჩვენივე მონაცემებიდან, როგორიცაა პერსონალური დოკუმენტი, წიგნი, PDF ფაილი ან საკუთრების მონაცემთა ბაზა?
LangChain საშუალებას გვაძლევს დავაკავშიროთ ა დიდი ენის მოდელი როგორიცაა GPT-4 ჩვენი საკუთარი მონაცემთა წყაროებისთვის. ეს სცილდება უბრალოდ ტექსტის ფრაგმენტის ჩატის ინტერფეისში ჩასმას. ამის ნაცვლად, ჩვენ შეგვიძლია მივმართოთ მთელი მონაცემთა ბაზას, რომელიც ივსება ჩვენივე მონაცემებით.
მას შემდეგ რაც მივიღებთ სასურველ ინფორმაციას, LangChain დაგვეხმარება კონკრეტული ქმედებების განხორციელებაში. მაგალითად, ჩვენ შეგვიძლია დავავალოთ მას გამოაგზავნოს ელ.წერილი, რომელიც შეიცავს გარკვეულ დეტალებს.
ამის მისაღწევად, ჩვენ მივყვებით მილსადენის მიდგომას LangChain-ის გამოყენებით. პირველ რიგში, ჩვენ ვიღებთ იმ დოკუმენტს, რომელიც გვინდა ენის მოდელი მითითება და დაყოფა უფრო მცირე ნაწილებად. ეს ნაჭრები შემდეგ ინახება როგორც ჩაშენება, რომელიც არის ტექსტის ვექტორული წარმოდგენები, ვექტორულ მონაცემთა ბაზაში.
ამ პარამეტრით, ჩვენ შეგვიძლია შევქმნათ ენის მოდელის აპლიკაციები, რომლებიც მიჰყვება სტანდარტულ მილსადენს: მომხმარებელი სვამს საწყის კითხვას, რომელიც შემდეგ იგზავნება ენის მოდელზე. კითხვის ვექტორული წარმოდგენა გამოიყენება ვექტორული მონაცემთა ბაზაში მსგავსების ძიების შესასრულებლად, ინფორმაციის შესაბამისი ნაჭრების ამოსაღებად.
ეს ნაწილაკები შემდეგ უბრუნდება ენის მოდელს, რაც მას საშუალებას აძლევს გასცეს პასუხი ან განახორციელოს სასურველი მოქმედება.
LangChain ხელს უწყობს აპლიკაციების შემუშავებას, რომლებიც აცნობიერებენ მონაცემებს, რადგან ჩვენ შეგვიძლია მივმართოთ საკუთარ მონაცემებს ვექტორულ მაღაზიაში და ავთენტური, რადგან მათ შეუძლიათ მიიღონ ქმედებები კითხვებზე პასუხის მიღმა. თ
ის ხსნის პრაქტიკული გამოყენების უამრავ შემთხვევას, განსაკუთრებით პერსონალურ დახმარებაში, სადაც დიდი ენის მოდელს შეუძლია გაუმკლავდეს დავალებებს, როგორიცაა ფრენების დაჯავშნა, ფულის გადარიცხვა ან დახმარება საგადასახადო საკითხებში.
გარდა ამისა, მნიშვნელოვანია ახალი საგნების შესწავლისა და სწავლის შედეგები, რადგან ენის მოდელს შეუძლია მიმართოს მთელ სილაბუსს და დააჩქაროს სასწავლო პროცესი. კოდირება, მონაცემთა ანალიზი და მონაცემთა მეცნიერება ასევე მოსალოდნელია ამ მიღწევების დიდ გავლენას.
ერთ-ერთი ყველაზე საინტერესო პერსპექტივა არის დიდი ენობრივი მოდელების დაკავშირება კომპანიის არსებულ მონაცემებთან, როგორიცაა მომხმარებლის ინფორმაცია ან მარკეტინგული მონაცემები. ეს ინტეგრაცია მოწინავე API-ებთან, როგორიცაა Meta's API ან Google's API, ჰპირდება ექსპონენტურ პროგრესს მონაცემთა ანალიტიკასა და მონაცემთა მეცნიერებაში.
როგორ ავაშენოთ ვებგვერდი (დემო)
ამჟამად, Langchain ხელმისაწვდომია Python და JavaScript პაკეტების სახით.
ჩვენ შეგვიძლია შევქმნათ საჩვენებელი ვებ აპი Streamlit, LangChain და OpenAI GPT-3 მოდელის გამოყენებით LangChain კონცეფციის განსახორციელებლად.
მაგრამ პირველ რიგში, ჩვენ უნდა დავაყენოთ რამდენიმე დამოკიდებულება, მათ შორის Streamlit, LangChain და OpenAI.
წინასწარი რეკვიზიტები
Streamlit: პოპულარული Python პაკეტი მონაცემთა მეცნიერებასთან დაკავშირებული ვებ აპლიკაციების შესაქმნელად
OpenAI: საჭიროა OpenAI-ის GPT-3 ენის მოდელზე წვდომა.
ამ დამოკიდებულებების დასაყენებლად გამოიყენეთ შემდეგი ბრძანებები cmd-ში:
pip install streamlit
pip install langchain
pip install openai
იმპორტის პაკეტები
ჩვენ ვიწყებთ საჭირო პაკეტების იმპორტით, როგორიცაა OpenAI, LangChain და Streamlit. ჩვენი ენის მოდელის ჯაჭვები განისაზღვრება და შესრულებულია LangChain-ის სამი კლასის გამოყენებით: LLMChain, SimpleSequentialChain და PromptTemplate.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
ძირითადი Setup
შემდეგ ჩვენი პროექტის სტრუქტურული საფუძველი შეიქმნა Streamlit სინტაქსის გამოყენებით. ჩვენ აპს მივეცით სათაური „რა არის ჭეშმარიტი: მარტივი თანმიმდევრული ჯაჭვის გამოყენება“ და ჩავრთეთ მარკირების ბმული GitHub საცავთან, რომელიც აპლიკაციის შთაგონების წყარო იყო.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
წინა ბოლო ვიჯეტები
ჩვენ დავაყენეთ აპლიკაცია რამდენიმე შესაბამისი ინფორმაციით, მარტივი Streamlit სინტაქსის გამოყენებით:
# If an API key has been provided, create an OpenAI language model instance
if API:
llm = OpenAI(temperature=0.7, openai_api_key=API)
else:
# If an API key hasn't been provided, display a warning message
st.warning("Enter your OPENAI API-KEY. Get your OpenAI API key from [here](https://platform.openai.com/account/api-keys).\n")
ფრონტის ვიჯეტების დასამატებლად
გარდა ამისა, ჩვენ უნდა მივაწოდოთ შეყვანის ვიჯეტი, რომელიც საშუალებას მისცემს ჩვენს მომხმარებლებს შეიყვანონ ნებისმიერი შეკითხვა.
# Add a text input box for the user's question
user_question = st.text_input(
"Enter Your Question : ",
placeholder = "Cyanobacteria can perform photosynthetsis , are they considered as plants?",
)
Ყველაფერი შესრულებულია! ჯაჭვები გამართულია!
ჩვენ ვიყენებთ ოპერაციების სხვადასხვა ჯაჭვს ერთად SimpleSequentialChain
მომხმარებლის შეკითხვაზე პასუხის გასაცემად. ჯაჭვები ხორციელდება შემდეგი თანმიმდევრობით, როდესაც მომხმარებელი ირჩევს "Tell me about it"
ღილაკს:
if st.button("Tell me about it", type="primary"):
# Chain 1: Generating a rephrased version of the user's question
template = """{question}\n\n"""
prompt_template = PromptTemplate(input_variables=["question"], template=template)
question_chain = LLMChain(llm=llm, prompt=prompt_template)
# Chain 2: Generating assumptions made in the statement
template = """Here is a statement:
{statement}
Make a bullet point list of the assumptions you made when producing the above statement.\n\n"""
prompt_template = PromptTemplate(input_variables=["statement"], template=template)
assumptions_chain = LLMChain(llm=llm, prompt=prompt_template)
assumptions_chain_seq = SimpleSequentialChain(
chains=[question_chain, assumptions_chain], verbose=True
)
# Chain 3: Fact checking the assumptions
template = """Here is a bullet point list of assertions:
{assertions}
For each assertion, determine whether it is true or false. If it is false, explain why.\n\n"""
prompt_template = PromptTemplate(input_variables=["assertions"], template=template)
fact_checker_chain = LLMChain(llm=llm, prompt=prompt_template)
fact_checker_chain_seq = SimpleSequentialChain(
chains=[question_chain, assumptions_chain, fact_checker_chain], verbose=True
)
# Final Chain: Generating the final answer to the user's question based on the facts and assumptions
template = """In light of the above facts, how would you answer the question '{}'""".format(
user_question
)
template = """{facts}\n""" + template
prompt_template = PromptTemplate(input_variables=["facts"], template=template)
answer_chain = LLMChain(llm=llm, prompt=prompt_template)
overall_chain = SimpleSequentialChain(
chains=[question_chain, assumptions_chain, fact_checker_chain, answer_chain],
verbose=True,
)
# Running all the chains on the user's question and displaying the final answer
st.success(overall_chain.run(user_question))
question_chain
: რომელიც არის ჩვენი მილსადენის პირველი ნაბიჯი, იღებს მომხმარებლის შეკითხვას, როგორც შეყვანისა და გამომავალი. მომხმარებლის მოთხოვნა ემსახურება ჯაჭვის შაბლონს.- კითხვასთან დაკავშირებულ განცხადებაზე დაყრდნობით,
assumptions_chain
წარმოქმნის ვარაუდების პუნქტიან სიასquestion_chain
როგორც შეყვანა. TheLLMChain
მდეOpenAI
LangChain-ის მოდელი გამოყენებული იქნა განცხადების ასაგებად. მომხმარებელს ევალება შექმნას იმ ვარაუდების სია, რომლებიც გაკეთდა განცხადების შესაქმნელად ამ ჯაჭვის შაბლონის გამოყენებით. - მიღებული შედეგების საფუძველზე
question_chain
მდეassumptions_chain
საქართველოსfact_checker_chain
წარმოქმნის მტკიცებათა ჩამონათვალს პუნქტების სახით. პრეტენზიები წარმოებულია გამოყენებითOpenAI
მოდელი დაLLMChain
LangChain-დან. მომხმარებელს ევალება დაადგინოს, არის თუ არა თითოეული პრეტენზია ზუსტი ან არასწორი და დაასაბუთოს ის, რაც არის. - ის
answer_chain
იყენებს გამოსავალსquestion_chain
,assumptions_chain
დაfact_checker_chain
როგორც მონაცემები მომხმარებლის კითხვაზე პასუხის შესაქმნელად წინა ჯაჭვების მიერ წარმოებული მონაცემების გამოყენებით. ამ ჯაჭვის შაბლონი მოითხოვს, რომ მომხმარებელმა უპასუხოს პირველ შეკითხვას შექმნილი ფაქტების გამოყენებით. - იმისათვის, რომ მივცეთ საბოლოო პასუხი მომხმარებლის შეკითხვაზე, რომელიც დაფუძნებულია ადრინდელი ჯაჭვების მიერ წარმოებულ ინფორმაციაზე, ჩვენ ამ ჯაჭვებს ვაერთიანებთ მთლიან ჯაჭვში. ჯაჭვების დასრულების შემდეგ ვიყენებთ
st.success()
აჩვენოს მომხმარებელს გამოსავალი.
დასკვნა
ჩვენ შეგვიძლია უბრალოდ გავაერთიანოთ სხვადასხვა ენობრივი მოდელის ქმედებები, რათა შევქმნათ უფრო რთული მილსადენების გამოყენებით SimpleSequentialChain
LangChain-ის მოდული. NLP აპლიკაციების ფართო სპექტრისთვის, მათ შორის ჩეთბოტების, კითხვა-პასუხის სისტემებისა და ენის თარგმნის ხელსაწყოებისთვის, ეს შეიძლება იყოს საკმაოდ გამოსადეგი.
LangChain-ის ბრწყინვალება ვლინდება აბსტრაქციის უნარში, რაც მომხმარებელს საშუალებას აძლევს კონცენტრირება მოახდინოს მიმდინარე საკითხზე და არა ენის მოდელირების სპეციფიკაზე.
LangChain ხდის დახვეწილი ენობრივი მოდელების შექმნის პროცესს უფრო მოსახერხებელი, წინასწარ მომზადებული მოდელების შეთავაზებით და შაბლონების შერჩევით.
ის გაძლევთ შესაძლებლობას დაარეგულიროთ ენის მოდელები საკუთარი მონაცემების გამოყენებით, რაც გაადვილებს ენის მოდელების მორგებას. ეს საშუალებას იძლევა უფრო ზუსტი, დომენის სპეციფიკური მოდელების შემუშავება, რომლებიც მოცემული სამუშაოსთვის აჯობებენ მომზადებულ მოდელებს.
ის SimpleSequentialChain
მოდული და LangChain-ის სხვა ფუნქციები მას ეფექტურ ინსტრუმენტად აქცევს დახვეწილი NLP სისტემების სწრაფად განვითარებისა და დანერგვისთვის.
დატოვე პასუხი