Innholdsfortegnelse[Gjemme seg][Forestilling]
LangChain er et banebrytende og robust verktøy utviklet for å utnytte kraften til store språkmodeller (LLM).
Disse LLM-ene har bemerkelsesverdige evner og kan effektivt takle et bredt spekter av oppgaver. Det er imidlertid viktig å merke seg at deres styrke ligger i deres generelle natur snarere enn i dybdedomeneekspertise. Dens popularitet har vokst raskt siden introduksjonen av GPT-4.
Mens LLM-er utmerker seg ved å håndtere ulike oppgaver, kan de møte begrensninger når det gjelder å gi spesifikke svar eller takle oppgaver som krever dyp domenekunnskap. Vurder for eksempel å bruke en LLM for å svare på spørsmål eller utføre oppgaver innenfor spesialiserte felt som medisin eller jus.
Mens LLM absolutt kan svare på generelle henvendelser om disse feltene, kan det være vanskelig å tilby mer detaljerte eller nyanserte svar som krever spesialisert kunnskap eller ekspertise.
Dette er fordi LLM-er er trent på enorme mengder tekstdata fra forskjellige kilder, noe som gjør dem i stand til å lære mønstre, forstå kontekst og generere sammenhengende svar. Imidlertid involverer opplæringen deres vanligvis ikke domenespesifikk eller spesialisert kunnskapsinnhenting i samme grad som menneskelige eksperter på disse feltene.
Derfor, mens LangChain, i forbindelse med LLM-er, kan være et uvurderlig verktøy for et bredt spekter av oppgaver, er det viktig å erkjenne at dyp domeneekspertise fortsatt kan være nødvendig i visse situasjoner. Menneskelige eksperter med spesialisert kunnskap kan gi den nødvendige dybden, nyanserte forståelsen og kontekstspesifikk innsikt som kan være utenfor mulighetene til LLMs alene.
Vi vil anbefale å se på LangChains dokumenter eller GitHub repository for en mer grundig forståelse av dens typiske brukstilfeller. Det anbefales på det sterkeste å få et større bilde av denne pakken.
Hvordan virker det?
For å forstå formålet og arbeidet til LangChain, la oss vurdere et praktisk eksempel. Vi er klar over at GPT-4 har imponerende generell kunnskap og kan gi pålitelige svar på en lang rekke spørsmål.
Men hva om vi ønsker spesifikk informasjon fra våre egne data, for eksempel et personlig dokument, bok, PDF-fil eller proprietær database?
LangChain lar oss koble til en stor språkmodell som GPT-4 til våre egne datakilder. Det går utover bare å lime inn en tekstbit i et chat-grensesnitt. I stedet kan vi referere til en hel database fylt med våre egne data.
Når vi har fått den ønskede informasjonen, kan LangChain hjelpe oss med å ta spesifikke handlinger. For eksempel kan vi instruere den til å sende en e-post som inneholder visse detaljer.
For å oppnå dette følger vi en pipeline-tilnærming ved å bruke LangChain. Først tar vi dokumentet vi ønsker språkmodell for å referere og dele den opp i mindre biter. Disse bitene blir deretter lagret som embeddings, som er vektorrepresentasjoner av teksten, i en vektordatabase.
Med dette oppsettet kan vi bygge språkmodellapplikasjoner som følger en standard pipeline: en bruker stiller et innledende spørsmål, som deretter sendes til språkmodellen. Spørsmålets vektorrepresentasjon brukes til å utføre et likhetssøk i vektordatabasen, og hente de relevante informasjonsbitene.
Disse delene føres deretter tilbake til språkmodellen, slik at den kan gi et svar eller utføre ønsket handling.
LangChain forenkler utviklingen av applikasjoner som er databevisste, da vi kan referere til våre egne data i et vektorlager, og autentiske, da de kan utføre handlinger utover å svare på spørsmål. T
hans åpner opp for en mengde praktiske brukssaker, spesielt innen personlig assistanse, der en stor språkmodell kan håndtere oppgaver som å bestille flyreiser, overføre penger eller bistå med skatterelaterte saker.
I tillegg er implikasjonene for å studere og lære nye fag betydelige, ettersom en språkmodell kan referere til en hel pensum og fremskynde læringsprosessen. Koding, dataanalyse og datavitenskap forventes også å bli sterkt påvirket av disse fremskrittene.
En av de mest spennende prospektene er å koble store språkmodeller til eksisterende bedriftsdata, som kundeinformasjon eller markedsføringsdata. Denne integrasjonen med avanserte APIer som Metas API eller Googles API lover eksponentiell fremgang innen dataanalyse og datavitenskap.
Hvordan bygge en nettside (demo)
Foreløpig er Langchain tilgjengelig som Python- og JavaScript-pakker.
Vi kan lage en demonstrasjons-webapp som bruker Streamlit, LangChain og OpenAI GPT-3-modellen for å implementere LangChain-konseptet.
Men først må vi installere noen få avhengigheter, inkludert Streamlit, LangChain og OpenAI.
Forutsetninger
Strømbelyst: En populær Python-pakke for å lage datavitenskap-relaterte nettapplikasjoner
OpenAI: Tilgang til OpenAIs GPT-3 språkmodell er nødvendig.
For å installere disse avhengighetene, bruk følgende kommandoer i cmd:
pip install streamlit
pip install langchain
pip install openai
Importer pakker
Vi starter med å importere de nødvendige pakkene, som OpenAI, LangChain og Streamlit. Våre språkmodellkjeder er definert og utført ved hjelp av tre klasser fra LangChain: LLMChain, SimpleSequentialChain og PromptTemplate.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Basic Setup
Det strukturelle grunnlaget for prosjektet vårt ble deretter satt opp ved hjelp av Streamlit-syntaks. Vi ga appen tittelen "What's TRUE: Using Simple Sequential Chain" og inkluderte en markdown-lenke til GitHub-depotet som fungerte som appens inspirasjon.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Frontend-widgeter
Vi setter opp appen med få relevant informasjon ved å bruke enkel Streamlit-syntaks:
# 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")
For å legge til frontend-widgets
Videre må vi gi en input-widget slik at brukerne våre kan legge inn spørsmål.
# 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?",
)
Ferdig! Kjedene er oppe og går!
Vi benytter ulike driftskjeder sammen med SimpleSequentialChain
for å svare på brukerens forespørsel. Kjedene utføres i følgende rekkefølge når brukeren velger "Tell me about it"
-knappen:
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 er det første trinnet i vår pipeline, mottar brukerens spørsmål som input og output. Brukerens spørring fungerer som kjedens mal.- Basert på en uttalelse knyttet til spørsmålet
assumptions_chain
genererer en punktliste over forutsetninger ved å bruke utdataene fraquestion_chain
som input. DeLLMChain
ogOpenAI
modell fra LangChain ble brukt til å konstruere utsagnet. Brukeren får i oppgave å lage en liste over forutsetningene som ble gjort for å produsere setningen ved å bruke malen for denne kjeden. - Basert på utgangene fra
question_chain
ogassumptions_chain
denfact_checker_chain
genererer en liste over påstander i form av kulepunkter. Kravene er produsert ved hjelp avOpenAI
modell ogLLMChain
fra LangChain. Brukeren har i oppgave å avgjøre om hvert krav er nøyaktig eller feil og gi begrunnelse for de som er det. - De
answer_chain
bruker utgangene fraquestion_chain
,assumptions_chain
ogfact_checker_chain
som input for å lage et svar på brukerens spørsmål ved å bruke dataene produsert av de tidligere kjedene. Malen for denne kjeden ber om at brukeren svarer på den første spørringen ved å bruke fakta som ble opprettet. - For å gi det ultimate svaret på brukerens henvendelse basert på informasjonen produsert av de tidligere kjedene, integrerer vi disse kjedene i den samlede kjeden. Etter at kjedene er ferdige, bruker vi
st.success()
for å vise brukeren løsningen.
konklusjonen
Vi kan ganske enkelt lenke sammen ulike språkmodellhandlinger for å lage mer kompliserte rørledninger ved å bruke SimpleSequentialChain
modul til LangChain. For et bredt utvalg av NLP-applikasjoner, inkludert chatbots, spørsmål-og-svar-systemer og språkoversettelsesverktøy, kan dette være ganske nyttig.
Briljansen til LangChain finnes i dens evne til å abstrahere, noe som gjør det mulig for brukeren å konsentrere seg om det aktuelle problemet i stedet for spesifikasjonene til språkmodellering.
LangChain gjør prosessen med å lage sofistikerte språkmodeller mer brukervennlige ved å tilby ferdigtrente modeller og et utvalg maler.
Det gir deg muligheten til å finjustere språkmodellene ved å bruke deres egne data, noe som gjør det enkelt å tilpasse språkmodellene. Dette muliggjør utvikling av mer presise, domenespesifikke modeller som for en gitt jobb overgår de trente modellene.
De SimpleSequentialChain
modul og andre funksjoner i LangChain gjør det til et effektivt verktøy for raskt å utvikle og distribuere sofistikerte NLP-systemer.
Legg igjen en kommentar