LangChain är ett banbrytande och robust verktyg utvecklat för att utnyttja kraften i stora språkmodeller (LLM).
Dessa LLM:er har anmärkningsvärda kapaciteter och kan effektivt hantera ett brett spektrum av uppgifter. Det är dock viktigt att notera att deras styrka ligger i deras allmänna karaktär snarare än djupgående domänexpertis. Dess popularitet har vuxit snabbt sedan introduktionen av GPT-4.
Även om LLM:er utmärker sig på att hantera olika uppgifter, kan de möta begränsningar när det gäller att ge specifika svar eller ta itu med uppgifter som kräver djupgående domänkunskap. Överväg till exempel att använda en LLM för att svara på frågor eller utföra uppgifter inom specialiserade områden som medicin eller juridik.
Även om LLM säkert kan svara på allmänna förfrågningar om dessa områden, kan det vara svårt att erbjuda mer detaljerade eller nyanserade svar som kräver specialiserad kunskap eller expertis.
Detta beror på att LLM:er utbildas på stora mängder textdata från olika källor, vilket gör det möjligt för dem att lära sig mönster, förstå sammanhang och generera sammanhängande svar. Men deras utbildning involverar vanligtvis inte domänspecifik eller specialiserad kunskapsinhämtning i samma utsträckning som mänskliga experter inom dessa områden.
Därför, även om LangChain, tillsammans med LLMs, kan vara ett ovärderligt verktyg för ett brett spektrum av uppgifter, är det viktigt att inse att djup domänexpertis fortfarande kan vara nödvändig i vissa situationer. Mänskliga experter med specialiserad kunskap kan tillhandahålla det nödvändiga djupet, nyanserade förståelsen och kontextspecifika insikter som kan vara bortom enbart LLM:s möjligheter.
Vi rekommenderar att du tittar på LangChains dokument eller GitHub repository för en mer grundlig förståelse av dess typiska användningsfall. Det rekommenderas starkt att få en större bild av detta paket.
Hur fungerar det?
För att förstå syftet och arbetet med LangChain, låt oss överväga ett praktiskt exempel. Vi är medvetna om att GPT-4 har imponerande allmän kunskap och kan ge tillförlitliga svar på en lång rad frågor.
Men vad händer om vi vill ha specifik information från våra egna data, såsom ett personligt dokument, bok, PDF-fil eller egen databas?
LangChain låter oss ansluta en stor språkmodell som GPT-4 till våra egna datakällor. Det går längre än att bara klistra in en textbit i ett chattgränssnitt. Istället kan vi referera till en hel databas fylld med våra egna data.
När vi har fått den önskade informationen kan LangChain hjälpa oss att vidta specifika åtgärder. Vi kan till exempel instruera den att skicka ett e-postmeddelande med vissa detaljer.
För att uppnå detta följer vi en pipeline-strategi med LangChain. Först tar vi det dokument vi vill ha språkmodell för att referera och dela upp det i mindre bitar. Dessa bitar lagras sedan som inbäddningar, vilket är det vektorrepresentationer av texten, i en vektordatabas.
Med denna inställning kan vi bygga språkmodellapplikationer som följer en standardpipeline: en användare ställer en första fråga, som sedan skickas till språkmodellen. Frågans vektorrepresentation används för att utföra en likhetssökning i vektordatabasen, för att hämta relevant information.
Dessa bitar återkopplas sedan till språkmodellen, vilket gör att den kan ge ett svar eller vidta önskad åtgärd.
LangChain underlättar utvecklingen av applikationer som är datamedvetna, eftersom vi kan referera till vår egen data i ett vektorlager, och autentiska, eftersom de kan vidta åtgärder utöver att svara på frågor. T
hans öppnar upp för en mängd praktiska användningsfall, särskilt inom personlig assistans, där en stor språkmodell kan hantera uppgifter som att boka flyg, överföra pengar eller hjälpa till med skatterelaterade frågor.
Dessutom är konsekvenserna för att studera och lära sig nya ämnen betydande, eftersom en språkmodell kan referera till en hel kursplan och påskynda inlärningsprocessen. Kodning, dataanalys och datavetenskap förväntas också i hög grad påverkas av dessa framsteg.
En av de mest spännande möjligheterna är att koppla stora språkmodeller till befintlig företagsdata, såsom kundinformation eller marknadsföringsdata. Denna integration med avancerade API:er som Metas API eller Googles API lovar exponentiella framsteg inom dataanalys och datavetenskap.
Hur man bygger en webbsida (demo)
För närvarande finns Langchain tillgängligt som Python- och JavaScript-paket.
Vi kan skapa en demonstrationswebbapp som använder Streamlit, LangChain och OpenAI GPT-3-modellen för att implementera LangChain-konceptet.
Men först måste vi installera några beroenden, inklusive Streamlit, LangChain och OpenAI.
Förutsättningar
Strömbelyst: Ett populärt Python-paket för att skapa datavetenskapsrelaterade webbapplikationer
OpenAI: Tillgång till OpenAI:s GPT-3 språkmodell behövs.
För att installera dessa beroenden, använd följande kommandon i cmd:
pip install streamlit
pip install langchain
pip install openai
Importera paket
Vi börjar med att importera de nödvändiga paketen, såsom OpenAI, LangChain och Streamlit. Våra språkmodellkedjor definieras och exekveras med hjälp av tre klasser från LangChain: LLMChain, SimpleSequentialChain och PromptTemplate.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Grundinställningar
Den strukturella grunden för vårt projekt sattes sedan upp med Streamlit-syntax. Vi gav appen titeln "What's TRUE: Using Simple Sequential Chain" och inkluderade en markdown-länk till GitHub-förrådet som fungerade som appens inspiration.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Front-end-widgets
Vi konfigurerar appen med få relevant information, med enkel Streamlit-syntax:
# 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")
För att lägga till front-end-widgets
Vidare måste vi tillhandahålla en inmatningswidget så att våra användare kan ställa in eventuella frågor.
# 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?",
)
Helt klar! Kedjorna är igång!
Vi anlitar olika verksamhetskedjor tillsammans med SimpleSequentialChain
för att svara på användarens fråga. Kedjorna utförs i följande ordning när användaren väljer "Tell me about it"
knapp:
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
: som är det första steget i vår pipeline, tar emot användarens fråga som input och output. Användarens fråga fungerar som kedjans mall.- Baserat på ett uttalande kopplat till frågan
assumptions_chain
genererar en punktlista med antaganden med hjälp av utdata frånquestion_chain
som input. DeLLMChain
ochOpenAI
modell från LangChain användes för att konstruera uttalandet. Användaren har till uppgift att skapa en lista över de antaganden som gjordes för att producera uttalandet med hjälp av mallen för denna kedja. - Baserat på utdata från
question_chain
ochassumptions_chain
, denfact_checker_chain
genererar en lista med påståenden i form av punktpunkter. Anspråken framställs med hjälp avOpenAI
modell ochLLMChain
från LangChain. Användaren har till uppgift att avgöra om varje påstående är korrekt eller felaktigt och att motivera dem som är det. - Smakämnen
answer_chain
använder utgångarna frånquestion_chain
,assumptions_chain
ochfact_checker_chain
som input för att skapa ett svar på användarens fråga med hjälp av data som producerats av de tidigare kedjorna. Mallen för denna kedja kräver att användaren svarar på den första frågan med de fakta som skapades. - För att ge det ultimata svaret på användarens förfrågan baserat på den information som producerats av de tidigare kedjorna, integrerar vi dessa kedjor i den övergripande kedjan. Efter att kedjorna är färdiga använder vi
st.success()
för att visa användaren lösningen.
Slutsats
Vi kan helt enkelt koppla ihop olika språkmodellåtgärder för att skapa mer komplicerade pipelines genom att använda SimpleSequentialChain
modul av LangChain. För en mängd olika NLP-applikationer, inklusive chatbots, fråge-och-svar-system och språköversättningsverktyg, kan detta vara till stor hjälp.
Briljansen hos LangChain återfinns i dess förmåga att abstrahera, vilket gör det möjligt för användaren att koncentrera sig på den aktuella frågan snarare än specifikationerna för språkmodellering.
LangChain gör processen att skapa sofistikerade språkmodeller mer användarvänlig genom att erbjuda förutbildade modeller och ett urval av mallar.
Det ger dig möjlighet att finjustera språkmodellerna med hjälp av deras egna data, vilket gör det enkelt att anpassa språkmodellerna. Detta möjliggör utveckling av mer precisa, domänspecifika modeller som för ett visst jobb överträffar de utbildade modellerna.
Smakämnen SimpleSequentialChain
modulen och andra funktioner i LangChain gör det till ett effektivt verktyg för att snabbt utveckla och distribuera sofistikerade NLP-system.
Kommentera uppropet