Inhoudsopgave[Zich verstoppen][Laten zien]
LangChain is een geavanceerde en robuuste tool die is ontwikkeld om de kracht van Large Language Models (LLM's) te benutten.
Deze LLM's beschikken over opmerkelijke capaciteiten en kunnen een breed scala aan taken efficiënt aan. Het is echter belangrijk op te merken dat hun kracht eerder in hun algemene aard ligt dan in diepgaande domeinexpertise. De populariteit is snel gegroeid sinds de introductie van GPT-4.
Hoewel LLM's uitblinken in het uitvoeren van verschillende taken, kunnen ze te maken krijgen met beperkingen als het gaat om het geven van specifieke antwoorden of het aanpakken van taken die diepgaande domeinkennis vereisen. Overweeg bijvoorbeeld het gebruik van een LLM om vragen te beantwoorden of taken uit te voeren binnen gespecialiseerde gebieden zoals geneeskunde of rechten.
Hoewel de LLM zeker kan reageren op algemene vragen over deze gebieden, kan het moeilijk zijn om meer gedetailleerde of genuanceerde antwoorden te geven die gespecialiseerde kennis of expertise vereisen.
Dit komt omdat LLM's zijn getraind op enorme hoeveelheden tekstgegevens uit verschillende bronnen, waardoor ze patronen kunnen leren, de context begrijpen en coherente antwoorden kunnen genereren. Hun training omvat echter doorgaans niet in dezelfde mate domeinspecifieke of gespecialiseerde kennisverwerving als menselijke experts op die gebieden.
Daarom, hoewel LangChain, in combinatie met LLM's, een hulpmiddel van onschatbare waarde kan zijn voor een breed scala aan taken, is het belangrijk om te erkennen dat diepgaande domeinexpertise in bepaalde situaties nog steeds nodig kan zijn. Menselijke experts met gespecialiseerde kennis kunnen de nodige diepgang, genuanceerd begrip en contextspecifieke inzichten bieden die mogelijk de mogelijkheden van LLM's alleen te boven gaan.
We raden aan om de documenten van LangChain te bekijken of GitHub repository voor een beter begrip van de typische use-cases. Het wordt sterk aangeraden om een groter beeld te krijgen van deze bundel.
Hoe werkt het?
Laten we, om het doel en het werk van LangChain te begrijpen, een praktisch voorbeeld bekijken. We zijn ons ervan bewust dat GPT-4 een indrukwekkende algemene kennis heeft en betrouwbare antwoorden kan geven op een breed scala aan vragen.
Maar wat als we specifieke informatie uit onze eigen gegevens willen, zoals een persoonlijk document, boek, pdf-bestand of eigen database?
Met LangChain kunnen we een groot taalmodel zoals GPT-4 naar onze eigen gegevensbronnen. Het gaat verder dan simpelweg een tekstfragment in een chatinterface plakken. In plaats daarvan kunnen we verwijzen naar een hele database gevuld met onze eigen gegevens.
Zodra we de gewenste informatie hebben verkregen, kan LangChain ons helpen bij het nemen van specifieke acties. We kunnen hem bijvoorbeeld de opdracht geven om een e-mail te sturen met bepaalde details.
Om dit te bereiken, volgen we een pijplijnbenadering met behulp van LangChain. Eerst nemen we het document dat we willen hebben taalmodel verwijzen en opdelen in kleinere stukken. Deze brokken worden vervolgens opgeslagen als inbeddingen vectorrepresentaties van de tekst, in een vectordatabase.
Met deze opzet kunnen we taalmodelapplicaties bouwen die een standaardpijplijn volgen: een gebruiker stelt een eerste vraag, die vervolgens naar het taalmodel wordt gestuurd. De vectorrepresentatie van de vraag wordt gebruikt om een overeenkomstzoekactie uit te voeren in de vectordatabase, waarbij de relevante stukjes informatie worden opgehaald.
Deze brokken worden vervolgens teruggekoppeld naar het taalmodel, zodat het een antwoord kan geven of de gewenste actie kan ondernemen.
LangChain vergemakkelijkt de ontwikkeling van applicaties die gegevensbewust zijn, omdat we naar onze eigen gegevens in een vectoropslag kunnen verwijzen, en authentiek, omdat ze acties kunnen ondernemen die verder gaan dan het beantwoorden van vragen. T
his opent een groot aantal praktische gebruiksscenario's, met name in persoonlijke assistentie, waar een groot taalmodel taken zoals het boeken van vluchten, het overmaken van geld of het helpen bij belastinggerelateerde zaken kan afhandelen.
Bovendien zijn de implicaties voor het bestuderen en leren van nieuwe onderwerpen aanzienlijk, aangezien een taalmodel kan verwijzen naar een volledige syllabus en het leerproces kan versnellen. Codering, data-analyse en datawetenschap zullen naar verwachting ook sterk worden beïnvloed door deze vooruitgang.
Een van de meest opwindende vooruitzichten is het koppelen van grote taalmodellen aan bestaande bedrijfsgegevens, zoals klantinformatie of marketinggegevens. Deze integratie met geavanceerde API's zoals Meta's API of Google's API belooft exponentiële vooruitgang op het gebied van data-analyse en datawetenschap.
Een webpagina bouwen (demo)
Momenteel is Langchain beschikbaar als Python- en JavaScript-pakketten.
We kunnen een demonstratie-webapp maken met behulp van Streamlit, LangChain en het OpenAI GPT-3-model om het LangChain-concept te implementeren.
Maar eerst moeten we een paar afhankelijkheden installeren, waaronder Streamlit, LangChain en OpenAI.
Pre-requisites
gestroomlijnd: Een populair Python-pakket voor het maken van data science-gerelateerde webapplicaties
Open AI: Toegang tot het GPT-3-taalmodel van OpenAI is vereist.
Gebruik de volgende opdrachten in cmd om deze afhankelijkheden te installeren:
pip install streamlit
pip install langchain
pip install openai
Pakketten importeren
We beginnen met het importeren van de benodigde pakketten, zoals OpenAI, LangChain en Streamlit. Onze taalmodelketens worden gedefinieerd en uitgevoerd met behulp van drie klassen van 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
Basic Setup
De structurele basis van ons project werd vervolgens neergezet met behulp van de Streamlit-syntaxis. We gaven de app de titel "What's TRUE: Using Simple Sequential Chain" en voegden een markdown-link naar de GitHub-repository toe die als inspiratie voor de app diende.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Frontend-widgets
We hebben de app opgezet met weinig relevante informatie, met behulp van de eenvoudige Streamlit-syntaxis:
# 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 toe te voegen
Verder moeten we een invoerwidget bieden waarmee onze gebruikers vragen kunnen invoeren.
# 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?",
)
Helemaal klaar! De kettingen zijn up and running!
We werken samen met verschillende werkketens SimpleSequentialChain
om te reageren op de vraag van de gebruiker. De ketens worden uitgevoerd in de volgende volgorde wanneer de gebruiker de selecteert "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
: wat de eerste stap in onze pijplijn is, ontvangt de vraag van de gebruiker als input en output. De vraag van de gebruiker dient als sjabloon voor de keten.- Op basis van een verklaring gekoppeld aan de vraag, de
assumptions_chain
genereert een opsomming van aannames met behulp van de uitvoer van dequestion_chain
als invoer. DeLLMChain
enOpenAI
model van LangChain werd gebruikt om de verklaring te construeren. De gebruiker moet een lijst maken van de aannames die zijn gemaakt om de verklaring te produceren met behulp van de sjabloon voor deze keten. - Op basis van de output van de
question_chain
enassumptions_chain
fact_checker_chain
genereert een lijst met beweringen in de vorm van opsommingstekens. De claims worden geproduceerd met behulp van deOpenAI
model enLLMChain
van LangChain. Het is de taak van de gebruiker om te bepalen of elke bewering juist of onjuist is en om een rechtvaardiging te geven voor de beweringen die dat wel zijn. - De
answer_chain
gebruikt de uitvoer van dequestion_chain
,assumptions_chain
enfact_checker_chain
als invoer om een antwoord op de vraag van de gebruiker te creëren met behulp van de gegevens die door de eerdere ketens zijn geproduceerd. De sjabloon voor deze keten vereist dat de gebruiker reageert op de eerste query met behulp van de feiten die zijn gemaakt. - Om op basis van de informatie van de eerdere ketens het ultieme antwoord te geven op de vraag van de gebruiker, integreren we deze ketens in de totale keten. Nadat de kettingen zijn voltooid, gebruiken we
st.success()
om de gebruiker de oplossing te laten zien.
Conclusie
We kunnen eenvoudig verschillende taalmodelacties aan elkaar koppelen om meer gecompliceerde pijplijnen te creëren met behulp van de SimpleSequentialChain
module van LangChain. Voor een breed scala aan NLP-toepassingen, waaronder chatbots, vraag-en-antwoordsystemen en hulpmiddelen voor het vertalen van talen, kan dit heel nuttig zijn.
De schittering van LangChain zit hem in zijn vermogen om te abstraheren, waardoor de gebruiker zich kan concentreren op het huidige probleem in plaats van op de details van taalmodellering.
LangChain maakt het proces van het maken van geavanceerde taalmodellen gebruiksvriendelijker door vooraf getrainde modellen en een selectie van sjablonen aan te bieden.
Het geeft u de mogelijkheid om de taalmodellen te verfijnen met behulp van hun eigen gegevens, waardoor het eenvoudig wordt om de taalmodellen aan te passen. Hierdoor kunnen nauwkeurigere, domeinspecifieke modellen worden ontwikkeld die voor een bepaalde taak beter presteren dan de getrainde modellen.
De SimpleSequentialChain
module en andere functies van LangChain maken het een effectief hulpmiddel voor het snel ontwikkelen en implementeren van geavanceerde NLP-systemen.
Laat een reactie achter