LangChain is in nijsgjirrich en robúst ark ûntwikkele om de krêft fan Large Language Models (LLM's) te benutten.
Dizze LLM's hawwe opmerklike mooglikheden en kinne in breed skala oan taken effisjint oanpakke. It is lykwols wichtich om te notearjen dat har sterkte leit yn har algemiene aard ynstee fan yngeande domeinekspertize. Syn populariteit is hurd groeid sûnt de ynfiering fan GPT-4.
Wylst LLM's útblinke yn it behanneljen fan ferskate taken, kinne se beheiningen hawwe as it giet om it jaan fan spesifike antwurden of it oanpakken fan taken dy't djippe domeinkennis nedich binne. Tink bygelyks oan it brûken fan in LLM om fragen te beantwurdzjen of taken út te fieren binnen spesjalisearre fjilden lykas medisinen of wet.
Wylst de LLM grif kin reagearje op algemiene fragen oer dizze fjilden, kin it stride om mear detaillearre of nuansearre antwurden oan te bieden dy't spesjalisearre kennis of saakkundigens nedich binne.
Dit is om't LLM's wurde oplaat op grutte hoemannichten tekstgegevens út ferskate boarnen, wêrtroch se patroanen kinne leare, kontekst begripe en gearhingjende antwurden generearje. Har training omfettet lykwols typysk net domeinspesifike of spesjalisearre kenniswinning yn deselde mjitte as minsklike saakkundigen op dy fjilden.
Dêrom, wylst LangChain, yn 'e mande mei LLM's, in ûnskatbere wearde ark kin wêze foar in breed skala oan taken, is it wichtich om te erkennen dat djippe domeinekspertize noch altyd nedich wêze kin yn bepaalde situaasjes. Minske saakkundigen mei spesjalisearre kennis kinne de nedige djipte, nuansearre begryp en kontekstspesifike ynsjoggen leverje dy't miskien bûten de mooglikheden fan LLM's allinich wêze kinne.
Wy riede oan om te sjen nei de dokuminten fan LangChain of GitHub repository foar in mear yngeande begryp fan har typyske gebrûksgefallen. It is sterk oan te rieden om in grutter byld fan dizze bondel te krijen.
Hoe wurket it?
Om it doel en wurk fan LangChain te begripen, litte wy in praktysk foarbyld beskôgje. Wy binne ús bewust dat GPT-4 yndrukwekkende algemiene kennis hat en betroubere antwurden kin leverje op in breed oanbod fan fragen.
Wat as wy lykwols spesifike ynformaasje wolle fan ús eigen gegevens, lykas in persoanlik dokumint, boek, PDF-bestân, of proprietêre databank?
LangChain lit ús ferbine a grut taalmodel lykas GPT-4 nei ús eigen boarnen fan gegevens. It giet fierder as gewoan in stikje tekst yn in petearynterface plakke. Ynstee dêrfan kinne wy ferwize nei in folsleine databank fol mei ús eigen gegevens.
Sadree't wy de winske ynformaasje krije, kin LangChain ús helpe by it nimmen fan spesifike aksjes. Wy kinne it bygelyks ynstruearje om in e-post te stjoeren mei bepaalde details.
Om dit te berikken, folgje wy in pipeline-oanpak mei LangChain. Earst nimme wy it dokumint dat wy wolle de taalmodel om te ferwizen en it te dielen yn lytsere brokken. Dizze brokken wurde dan opslein as ynbêden, dy't binne vector foarstellings fan de tekst, yn in Vector Database.
Mei dizze opset kinne wy taalmodelapplikaasjes bouwe dy't in standert pipeline folgje: in brûker stelt in earste fraach, dy't dan nei it taalmodel stjoerd wurdt. De fektorfertsjintwurdiging fan 'e fraach wurdt brûkt om in oerienkomstsykjen yn' e Vector Database út te fieren, en de relevante brokken ynformaasje op te heljen.
Dizze brokken wurde dan weromfierd nei it taalmodel, wêrtroch it in antwurd kin jaan of de winske aksje útfiere.
LangChain fasilitearret de ûntwikkeling fan tapassingen dy't gegevens bewust binne, om't wy ús eigen gegevens kinne ferwize yn in fektorwinkel, en autentyk, om't se aksjes kinne nimme bûten it beäntwurdzjen fan fragen. T
syn iepenet in mannichte fan praktyske gebrûk gefallen, benammen yn persoanlike bystân, dêr't in grut taalmodel kin omgean taken lykas it bestellen fan flechten, oermeitsje jild, of assistinsje mei belesting-relatearre saken.
Derneist binne de gefolgen foar it studearjen en learen fan nije fakken signifikant, om't in taalmodel in heule syllabus ferwize kin en it learproses fersnelt. Kodearring, gegevensanalyse en gegevenswittenskip wurde ek ferwachte dat se sterk beynfloede wurde troch dizze foarútgong.
Ien fan de meast spannende perspektiven is it ferbinen fan grutte taalmodellen oan besteande bedriuwsgegevens, lykas klantynformaasje of marketinggegevens. Dizze yntegraasje mei avansearre API's lykas Meta's API of Google's API belooft eksponinsjele foarútgong yn gegevensanalytyk en gegevenswittenskip.
Hoe kinne jo in webside bouwe (demo)
Op it stuit is Langchain beskikber as Python- en JavaScript-pakketten.
Wy kinne in demonstraasje-webapp meitsje mei Streamlit, LangChain, en it OpenAI GPT-3-model om it LangChain-konsept te ymplementearjen.
Mar earst moatte wy in pear ôfhinklikens ynstallearje, ynklusyf Streamlit, LangChain, en OpenAI.
Pre-requisites
Streamlit: In populêr Python-pakket foar it meitsjen fan gegevenswittenskip-relatearre webapplikaasjes
OpenAI: Tagong ta it GPT-3-taalmodel fan OpenAI is nedich.
Om dizze ôfhinklikens te ynstallearjen, brûk de folgjende kommando's yn cmd:
pip install streamlit
pip install langchain
pip install openai
Ymportearje pakketten
Wy begjinne mei it ymportearjen fan de fereaske pakketten, lykas OpenAI, LangChain, en Streamlit. Us taalmodelketen wurde definieare en útfierd mei trije klassen fan LangChain: LLMChain, SimpleSequentialChain, en PromptTemplate.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Basisynstelling
De strukturele basis fan ús projekt waard doe opsteld mei Streamlit-syntaksis. Wy joegen de app de titel "What's TRUE: Using Simple Sequential Chain" en omfette in markdown-keppeling nei it GitHub-repository dat tsjinne as de ynspiraasje fan 'e app.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Front-End Widgets
Wy sette de app op mei in pear relevante ynformaasje, mei help fan ienfâldige Streamlit-syntaksis:
# 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")
Om front-end widgets ta te foegjen
Fierder moatte wy in ynfierwidget leverje om ús brûkers alle fragen yn te litten.
# 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?",
)
Alles klear! De keatlingen binne op en rinne!
Wy brûke ferskate keatlingen fan operaasjes tegearre mei SimpleSequentialChain
om te reagearjen op de fraach fan de brûker. De keatlingen wurde útfierd yn de folgjende folchoarder doe't de brûker selektearret de "Tell me about it"
knop:
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
: dat is de earste stap yn ús pipeline, ûntfangt de fraach fan 'e brûker as ynfier en útfier. De query fan de brûker tsjinnet as sjabloan fan 'e ketting.- Op grûn fan in ferklearring keppele oan de fraach, de
assumptions_chain
genereart in bullet-point list fan oannames mei help fan de útfier fan dequestion_chain
as ynfier. DeLLMChain
enOpenAI
model fan LangChain waard brûkt om de ferklearring te konstruearjen. De brûker hat de opdracht om in list te meitsjen fan 'e oannames dy't makke binne om de ferklearring te meitsjen mei it sjabloan foar dizze ketting. - Op grûn fan de útgongen fan de
question_chain
enassumptions_chain
, defact_checker_chain
genereart in list mei bewearingen yn 'e foarm fan kûgelpunten. De oanspraken wurde produsearre mei help fan deOpenAI
model enLLMChain
fan LangChain. De brûker hat de opdracht om te bepalen as elke claim krekt of ferkeard is en rjochtfeardiging te jaan foar dyjingen dy't dat binne. - De
answer_chain
brûkt de útgongen fan dequestion_chain
,assumptions_chain
, enfact_checker_chain
as ynputs om in antwurd te meitsjen op 'e fraach fan 'e brûker mei de gegevens produsearre troch de eardere keatlingen. It sjabloan foar dizze keatling freget dat de brûker reagearret op 'e earste fraach mei de feiten dy't makke binne. - Om it ultime antwurd te jaan op 'e fraach fan' e brûker basearre op 'e ynformaasje produsearre troch de eardere keatlingen, yntegrearje wy dizze keatlingen yn' e algemiene keten. Nei't de keatlingen foltôge binne, brûke wy
st.success()
om de brûker de oplossing sjen te litten.
Konklúzje
Wy kinne gewoan keatling ferskillende taal model aksjes te meitsjen mear yngewikkelder pipelines troch it brûken fan de SimpleSequentialChain
module fan LangChain. Foar in breed ferskaat oan NLP-applikaasjes, ynklusyf chatbots, fraach-en-antwurd-systemen, en ark foar taaloersetting, kin dit heul nuttich wêze.
De briljantheid fan LangChain wurdt fûn yn syn kapasiteit om te abstraheren, wêrtroch de brûker kin konsintrearje op it aktuele probleem yn stee fan de spesifiken fan taalmodellering.
LangChain makket it proses fan it meitsjen fan ferfine taalmodellen brûkerfreonliker troch it oanbieden fan pre-trained modellen en in seleksje fan sjabloanen.
It jout jo de opsje om de taalmodellen te fine-tunen mei har eigen gegevens, wêrtroch it ienfâldich is om de taalmodellen oan te passen. Dit makket it mooglik om te ûntwikkeljen mear sekuere, domein-spesifike modellen dy't, foar in opjûne baan, de oplate modellen prestearje.
De SimpleSequentialChain
module en oare funksjes fan LangChain meitsje it in effektyf ark foar fluch ûntwikkeljen en ynsette ferfine NLP systemen.
Leave a Reply