Från noll till avancerad promptteknik med Langchain i Python

En viktig aspekt av stora språkmodeller (LLM) är antalet parametrar som dessa modeller använder för att lära sig. Ju fler parametrar en modell har, desto bättre kan den förstå relationen mellan ord och fraser. Detta innebär att modeller med miljarder parametrar har förmågan att generera olika kreativa textformat och besvara öppna och utmanande frågor på ett informativt sätt.

LLM-modeller som ChatGPT, som använder Transformer-modellen, är skickliga på att förstå och generera mänskligt språk, vilket gör dem användbara för tillämpningar som kräver naturligt språkförståelse. Men de är inte utan begränsningar, som inkluderar föråldrad kunskap, oförmåga att interagera med externa system, brist på kontextförståelse och ibland genererar de trovärdiga men felaktiga eller meningslösa svar, bland annat.

Att hantera dessa begränsningar kräver integration av LLM-modeller med externa datakällor och funktioner, vilket kan medföra komplexitet och kräva omfattande kodnings- och datahanteringsfärdigheter. Detta, i kombination med utmaningarna att förstå AI-koncept och komplexa algoritmer, bidrar till den inlärningskurva som är förknippad med att utveckla tillämpningar med LLM-modeller.

Trots detta kan integrationen av LLM-modeller med andra verktyg för att forma LLM-baserade tillämpningar omdefiniera vår digitala landskap. Potentialen för sådana tillämpningar är enorm, inklusive förbättring av effektivitet och produktivitet, förenkling av uppgifter, förbättring av beslutsfattande och tillhandahållande av personanpassade upplevelser.

I den här artikeln kommer vi att dyka djupare in i dessa frågor, utforska avancerade tekniker för promptteknik med Langchain, erbjuda tydliga förklaringar, praktiska exempel och steg-för-steg-instruktioner om hur man implementerar dem.

Langchain, ett toppmodernt bibliotek, bringar bekvämlighet och flexibilitet till design, implementering och finjustering av promptrar. När vi packar upp principerna och praktikerna för promptteknik kommer du att lära dig hur du kan utnyttja Langchains kraftfulla funktioner för att utnyttja styrkorna hos SOTA-generativa AI-modeller som GPT-4.

Att förstå promptrar

Innan vi dyker in i de tekniska aspekterna av promptteknik är det viktigt att förstå begreppet promptrar och deras betydelse.

En ‘prompt‘ är en sekvens av token som används som indata till en språkmodell, som instruerar den att generera en viss typ av svar. Promptrar spelar en avgörande roll i att styra modellens beteende. De kan påverka kvaliteten på den genererade texten, och när de är korrekt utformade, kan de hjälpa modellen att tillhandahålla insiktsfulla, precisa och kontextspecifika resultat.

Promptteknik är konsten och vetenskapen att designa effektiva promptrar. Målet är att utvinna det önskade svaret från en språkmodell. Genom att noggrant välja och strukturera promptrar kan man guida modellen mot att generera mer precisa och relevanta svar. I praktiken innebär detta att finjustera inmatningsfraser för att anpassa sig till modellens utbildning och strukturbias.

Sophistikeringen av promptteknik sträcker sig från enkla tekniker, som att mata modellen med relevanta nyckelord, till mer avancerade metoder som involverar designen av komplexa, strukturerade promptrar som utnyttjar modellens interna mekanismer till sin fördel.

Langchain: Det snabbast växande promptverktyget

LangChain, lanserat i oktober 2022 av Harrison Chase, har blivit ett av de högst rankade öppna källkodsramverken på GitHub 2023. Det erbjuder ett förenklat och standardiserat gränssnitt för att integrera stora språkmodeller (LLM) i tillämpningar. Det erbjuder också ett funktionrikt gränssnitt för promptteknik, som tillåter utvecklare att experimentera med olika strategier och utvärdera sina resultat. Genom att använda Langchain kan du utföra promptteknikuppgifter mer effektivt och intuitivt.

LangFlow fungerar som ett användargränssnitt för att orkestrera LangChain-komponenter till en exekverbar flödesschema, vilket möjliggör snabb prototypning och experimentering.

LangChain fyller en kritisk lucka i AI-utveckling för massorna. Det möjliggör en mängd NLP-tillämpningar, såsom virtuella assistenter, innehållsgenerering, frågesvarssystem och mer, för att lösa en rad verkliga problem.

Istället för att vara en fristående modell eller leverantör förenklar LangChain interaktionen med olika modeller, vilket utökar möjligheterna för LLM-tillämpningar bortom begränsningarna för ett enkelt API-anrop.

LangChains arkitektur

LangChains huvudkomponenter inkluderar Model I/O, Promptmallar, Minne, Agenter och kedjor.

Model I/O

LangChain möjliggör en smidig anslutning till olika språkmodeller genom att omsluta dem med ett standardiserat gränssnitt som kallas Model I/O. Detta möjliggör en smidig modellväxling för optimering eller bättre prestanda. LangChain stöder olika språkmodellleverantörer, inklusive OpenAI, HuggingFace, Azure, Fireworks och mer.

Promptmallar

Dessa används för att hantera och optimera interaktioner med LLM-modeller genom att tillhandahålla koncisa instruktioner eller exempel. Att optimera promptrar förbättrar modellens prestanda, och deras flexibilitet bidrar betydligt till inmatningsprocessen.

Ett enkelt exempel på en promptmall:

<p>from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=[&amp;quot;subject&amp;quot;],
template=&amp;quot;Vad är de senaste framstegen inom {subject}-området?&amp;quot;)
print(prompt.format(subject=&amp;quot;Naturlig språkbehandling&amp;quot;))</p>

När vi fortsätter att öka komplexiteten möter vi mer sofistikerade mönster i LangChain, såsom Reason och Act (ReAct)-mönstret. ReAct är ett viktigt mönster för aktionsutförande där agenten tilldelar en uppgift till ett lämpligt verktyg, anpassar inmatningen för det och tolkar dess utdata för att utföra uppgiften. Följande Python-exempel visar ett ReAct-mönster. Det demonstrerar hur en prompt struktureras i LangChain, med hjälp av en serie tankar och handlingar för att resonera genom ett problem och producera ett slutligt svar:

PREFIX = """Svara på följande fråga med hjälp av tillgängliga verktyg:"""
FORMAT_INSTRUCTIONS = """Följ detta format:
Fråga: {input_question}
Tanke: din första tanke på frågan
Handling: din valda handling från [{tool_names}]
Handling Inmatning: din inmatning för handlingen
Observation: handlingens resultat"""
SUFFIX = """Börja!
Fråga: {input}
Tanke:{agent_scratchpad}"""

Minne

Minne är ett kritiskt koncept i LangChain, som möjliggör för LLM-modeller och verktyg att behålla information över tid. Detta beteende förbättrar prestandan för LangChain-tillämpningar genom att lagra tidigare svar, användarinteraktioner, miljöns tillstånd och agentens mål. Strategierna ConversationBufferMemory och ConversationBufferWindowMemory hjälper till att spåra hela eller senaste delar av en konversation. För en mer avancerad approach möjliggör ConversationKGMemory-strategin att koda konversationen som en kunskapsgraf som kan matas tillbaka till promptrar eller användas för att förutsäga svar utan att anropa LLM-modellen.

Agenter

En agent interagerar med världen genom att utföra handlingar och uppgifter. I LangChain kombinerar agenter verktyg och kedjor för uppgiftsutförande. Den kan etablera en anslutning till den yttre världen för informationshämtning för att komplettera LLM-modellens kunskap, vilket övervinner deras inbyggda begränsningar. De kan besluta att passa beräkningar till en beräkningsmaskin eller Python-tolk beroende på situationen.

Agenter är utrustade med underkomponenter:

• Verktyg: Dessa är funktionella komponenter.
• Verktygslådor: Samlingar av verktyg.
• Agent-utförare: Detta är utförandemekanismen som tillåter att välja mellan verktyg.

Agenter i LangChain följer också Zero-shot ReAct-mönstret, där beslutet baseras endast på verktygets beskrivning. Denna mekanism kan utökas med minne för att ta hänsyn till hela konversationshistoriken. Med ReAct, istället för att be en LLM-modell att slutföra din text, kan du uppmana den att svara i en tanke/handling/observationsslinga.

Kedjor

Kedjor, som namnet antyder, är sekvenser av operationer som tillåter LangChain-biblioteket att bearbeta språkmodellindata och utdata smidigt. Dessa integrerade komponenter i LangChain består i grunden av länkar, som kan vara andra kedjor eller primitiva såsom promptrar, språkmodeller eller verktyg.

Tänk dig en kedja som en transportband i en fabrik. Varje steg på detta band representerar en viss operation, som kan vara att anropa en språkmodell, applicera en Python-funktion på en text eller till och med uppmana modellen på ett visst sätt.

LangChain kategoriserar sina kedjor i tre typer: Verktygskedjor, Generiska kedjor och Kombinera dokumentkedjor. Vi kommer att dyka in i Verktygskedjor och Generiska kedjor för vår diskussion.

• Verktygskedjor är specifikt utformade för att extrahera precisa svar från språkmodeller för snävt definierade uppgifter. Till exempel, låt oss ta en titt på LLMMathChain. Denna verktygskedja möjliggör för språkmodeller att utföra matematiska beräkningar. Den accepterar en fråga på naturligt språk, och språkmodellen genererar i sin tur en Python-kodsnutt som sedan körs för att producera svaret.
• Generiska kedjor, å andra sidan, fungerar som byggblock för andra kedjor men kan inte användas direkt på egen hand. Dessa kedjor, såsom LLMChain, är grundläggande och kombineras ofta med andra kedjor för att utföra komplexa uppgifter. Till exempel används LLMChain ofta för att fråga en språkmodellobjekt genom att formatera inmatningen baserat på en given promptmall och sedan skicka den till språkmodellen.

Steg-för-steg-implementering av promptteknik med Langchain

Vi kommer att guida dig genom processen att implementera promptteknik med Langchain. Innan du fortsätter, se till att du har installerat nödvändig programvara och paket.

Du kan dra nytta av populära verktyg som Docker, Conda, Pip och Poetry för att installera LangChain. De relevanta installationsfilerna för var och en av dessa metoder kan hittas inom LangChain-repositoriet på https://github.com/benman1/generative_ai_with_langchain. Detta inkluderar en Dockerfile för Docker, en requirements.txt för Pip, en pyproject.toml för Poetry och en langchain_ai.yml-fil för Conda.

I vår artikel kommer vi att använda Pip, den standardpakethanteraren för Python, för att underlätta installation och hantering av tredjepartsbibliotek. Om det inte ingår i din Python-distribution kan du installera Pip genom att följa instruktionerna på https://pip.pypa.io/.

För att installera ett bibliotek med Pip, använd kommandot pip install biblioteksnamn.

Men Pip hanterar inte miljöer på egen hand. För att hantera olika miljöer använder vi verktyget virtualenv.

I nästa avsnitt kommer vi att diskutera modellintegrationer.

Steg 1: Installera Langchain

Först måste du installera Langchain-paketet. Vi använder Windows-operativsystem. Kör följande kommando i din terminal för att installera det:

pip install langchain

Steg 2: Importera Langchain och andra nödvändiga moduler

Nästa steg är att importera Langchain tillsammans med andra nödvändiga moduler. Här importerar vi också transformers-biblioteket, som används flitigt i NLP-uppgifter.

<p>import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Steg 3: Ladda förtränad modell

Open AI

OpenAI-modeller kan bekvämt integreras med LangChain-biblioteket eller OpenAI Python-klientbiblioteket. Noterbart är att OpenAI tillhandahåller en Embedding-klass för textinbäddningsmodeller. Två viktiga LLM-modeller är GPT-3.5 och GPT-4, som skiljer sig främst i tokenlängd. Prissättning för varje modell kan hittas på OpenAI:s webbplats. Medan det finns mer avancerade modeller som GPT-4-32K som har högre tokenacceptans, är deras tillgänglighet via API inte alltid garanterad.

Tillgång till dessa modeller kräver en OpenAI API-nyckel. Detta kan göras genom att skapa ett konto på OpenAI-plattformen, ställa in faktureringsinformation och generera en ny hemlig nyckel.

<p>import os
os.environ[&amp;quot;OPENAI_API_KEY&amp;quot;] = &#039;din-openai-token&#039;</p>

Efter att ha skapat nyckeln kan du ställa in den som en miljövariabel (OPENAI_API_KEY) eller skicka den som en parameter under klassinstansiering för OpenAI-samtal.

Överväg ett LangChain-skript som visar interaktionen med OpenAI-modellerna:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# LLM-modellen tar en prompt som indata och genererar ett svar
prompt = "Vem är president i USA?"
completion = llm(prompt)

<p>Den nuvarande presidenten i USA är Joe Biden.</p>

I det här exemplet initieras en agent för att utföra beräkningar. Agenten tar emot indata, en enkel adderingsuppgift, bearbetar den med den tillhandahållna OpenAI-modellen och returnerar resultatet.

Hugging

Hugging Face är ett KOSTNADSFRI Transformers Python-bibliotek, kompatibelt med PyTorch, TensorFlow och JAX, och innehåller implementeringar av modeller som BERT, T5 och så vidare.

Hugging Face erbjuder också Hugging Face Hub, en plattform för att vara värd för kodrepositoryer, maskinlärningsmodeller, datamängder och webbapplikationer.

För att använda Hugging Face som leverantör för dina modeller behöver du ett konto och API-nycklar, som kan erhållas från deras webbplats. Token kan göras tillgänglig i din miljö som HUGGINGFACEHUB_API_TOKEN.

Överväg följande Python-snutt som använder en öppen källkodsmodell utvecklad av Google (GOOGL ), Flan-T5-XXL-modellen:

from langchain.llms import HuggingFaceHub

<p>llm = HuggingFaceHub(model_kwargs={&amp;quot;temperature&amp;quot;: 0.5, &amp;quot;max_length&amp;quot;: 64},repo_id=&amp;quot;google/flan-t5-xxl&amp;quot;)
prompt = &amp;quot;I vilket land ligger Tokyo?&amp;quot;
completion = llm(prompt)
print(completion)</p>

Detta skript tar en fråga som indata och returnerar ett svar, som visar kunskapen och förutsägelseförmågan hos modellen.

Steg 4: Grundläggande promptteknik

För att börja med kommer vi att generera en enkel prompt och se hur modellen svarar.

prompt = 'Översätt följande engelsk text till franska: "{0}"'
input_text = 'Hej, hur mår du?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

<p>generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

I ovanstående kodsnutt tillhandahåller vi en prompt för att översätta engelsk text till franska. Språkmodellen försöker sedan översätta den givna texten baserat på prompten.

Steg 5: Avancerad promptteknik

Medan ovanstående tillvägagångssätt fungerar bra, utnyttjar det inte fullt ut kraften i promptteknik. Låt oss förbättra det genom att introducera mer komplexa promptstrukturer.

prompt = 'Som en mycket skicklig franskspråkig översättare, översätt följande engelska text till franska: "{0}"'
input_text = 'Hej, hur mår du?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

<p>generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

I den här kodsnutten modifierar vi prompten för att föreslå att översättningen utförs av en ‘mycket skicklig franskspråkig översättare’. Förändringen i prompten kan leda till förbättrade översättningar, eftersom modellen nu antar en expertroll.

Att bygga ett akademiskt litteraturfrågesystem med Langchain

Vi kommer att bygga ett akademiskt litteraturfrågesystem med LangChain som kan besvara frågor om nyligen publicerade akademiska artiklar.

Först och främst, för att ställa in vår miljö, installerar vi de nödvändiga beroendena.

pip install langchain arxiv openai transformers faiss-cpu

Efter installationen skapar vi ett nytt Python-anteckningsblock och importerar de nödvändiga biblioteken:

from langchain.llms import OpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.docstore.document import Document
import arxiv

Kärnan i vårt frågesystem är förmågan att hämta relevanta akademiska artiklar relaterade till ett visst område, här betraktar vi Naturlig språkbehandling (NLP), med hjälp av arXiv-akademidatabasen. För att utföra detta definierar vi en funktion get_arxiv_data(max_results=10). Denna funktion samlar de senaste NLP-artiklarnas sammanfattningar från arXiv och kapslar in dem i LangChain-dokumentobjekt, med sammanfattningen som innehåll och det unika post-ID:t som källa.

Vi kommer att använda arXiv-API:t för att hämta de senaste artiklarna relaterade till NLP:

<p>def get_arxiv_data(max_results=10):
search = arxiv.Search(
query=&amp;quot;NLP&amp;quot;,
max_results=max_results,
sort_by=arxiv.SortCriterion.SubmittedDate,
)</p>

documents = []

<p>for result in search.results():
documents.append(Document(
page_content=result.summary,
metadata={&amp;quot;source&amp;quot;: result.entry_id},
))</p>

return documents

Denna funktion hämtar sammanfattningarna av de senaste NLP-artiklarna från arXiv och konverterar dem till LangChain-dokumentobjekt. Vi använder artiklarnas sammanfattning och dess unika post-ID (URL till artikeln) som innehåll och källa, respectively.

def print_answer(question):
print(
chain(
{
"input_documents": sources,
"question": question,
},
return_only_outputs=True,
)["output_text"]
)

Låt oss definiera vår korpus och ställa in LangChain:

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(temperature=0))

Med vårt akademiska frågesystem redo, kan vi testa det genom att ställa en fråga:

print_answer("Vad är de senaste framstegen inom NLP?")

Utmatningen kommer att vara svaret på din fråga, med källhänvisningar till de källor från vilka informationen hämtades. Till exempel:

<p>De senaste framstegen inom NLP inkluderar Retriever-augmenterade instruktionsföljande modeller och en ny beräkningsram för att lösa alternerande strömoptimala flödesproblem (ACOPF) med hjälp av grafikprocessorer (GPU).
KÄLLOR: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Du kan enkelt byta modell eller ändra systemet enligt dina behov. Till exempel, här byter vi till GPT-4, vilket resulterar i ett mycket bättre och mer detaljerat svar.

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4",temperature=0))

<p>De senaste framstegen inom Naturlig språkbehandling (NLP) inkluderar utvecklingen av Retriever-augmenterade instruktionsföljande modeller för informationshämtning, såsom frågesvar (QA). Dessa modeller kan anpassas till olika informationsdomäner och uppgifter utan ytterligare finjustering. Men de kämpar ofta för att hålla sig till den tillhandahållna kunskapen och kan hallucinera i sina svar. Ett annat framsteg är introduktionen av en beräkningsram för att lösa alternerande strömoptimala flödesproblem (ACOPF) med hjälp av grafikprocessorer (GPU). Denna approach använder en single-instruction, multiple-data (SIMD)-abstraktion av icke-linjära program (NLP) och använder en kondenserad-utrymme-inre-punktsmetod (IPM) med en ojämnhetsrelaxeringsstrategi. Denna strategi möjliggör faktorisering av KKT-matrisen utan numerisk pivoting, vilket tidigare har hindrat parallelliseringen av IPM-algoritmen.
KÄLLOR: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

En token i GPT-4 kan vara så kort som ett tecken eller så lång som ett ord. Till exempel kan GPT-4-32K bearbeta upp till 32 000 token i ett enda körning, medan GPT-4-8K och GPT-3.5-turbo stöder 8 000 och 4 000 token, respektive. Men det är viktigt att notera att varje interaktion med dessa modeller medför en kostnad som är direkt proportionell mot antalet bearbetade token, antingen indata eller utdata.

I sammanhanget med vårt frågesystem, om en del av den akademiska litteraturen överskrider den maximala tokenbegränsningen, kommer systemet att misslyckas med att bearbeta den i sin helhet, vilket påverkar kvaliteten och fullständigheten hos svaren. För att komma runt detta problem kan texten brytas ned i mindre delar som följer tokenbegränsningen.

FAISS (Facebook AI Similarity Search) (META ) hjälper till att snabbt hitta de mest relevanta textdelarna relaterade till användarens fråga. Det skapar en vektorrepresentation av varje textdel och använder dessa vektorer för att identifiera och hämta de delar som är mest lika vektorrepresentationen av en given fråga.

Det är viktigt att komma ihåg att även med användning av verktyg som FAISS kan behovet av att dela texten i mindre delar på grund av tokenbegränsningar ibland leda till förlust av kontext, vilket påverkar kvaliteten på svaren. Därför är det viktigt att hantera och optimera tokenanvändningen noggrant när man arbetar med dessa stora språkmodeller.

pip install faiss-cpu langchain CharacterTextSplitter

Efter att ha säkerställt att ovanstående bibliotek är installerade, kör

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.faiss import FAISS
from langchain.text_splitter import CharacterTextSplitter
documents = get_arxiv_data(max_results=10) # Vi kan nu använda mer data
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
for chunk in splitter.split_text(document.page_content):
document_chunks.append(Document(page_content=chunk, metadata=document.metadata))

<p>search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())</p>

<p>chain = load_qa_with_sources_chain(OpenAI(temperature=0))</p>

<p>def print_answer(question):
print(
chain(
{
&amp;quot;input_documents&amp;quot;: search_index.similarity_search(question, k=4),
&amp;quot;question&amp;quot;: question,
},
return_only_outputs=True,
)[&amp;quot;output_text&amp;quot;]
)

Med koden komplett har vi nu ett kraftfullt verktyg för att fråga den senaste akademiska litteraturen inom NLP-området.

De senaste framstegen inom NLP inkluderar användningen av djupa neurala nätverk (DNN) för automatisk textanalys och NLP-uppgifter som stavkontroll, språkdetection, entitetsutvinning, författardetection, frågesvar och andra uppgifter.
KÄLLOR: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Slutsats

Integrationen av stora språkmodeller (LLM) i tillämpningar har accelererat antagandet inom flera domäner, inklusive språköversättning, sentimentanalys och informationshämtning. Promptteknik är ett kraftfullt verktyg för att maximera potentialen hos dessa modeller, och Langchain leder vägen i att förenkla denna komplexa uppgift. Dess standardiserade gränssnitt, flexibla promptmallar, robust modellintegration och den innovativa användningen av agenter och kedjor säkerställer optimala resultat för LLM-modellernas prestanda.

Men trots dessa framsteg finns det några viktiga punkter att komma ihåg. När du använder Langchain är det viktigt att förstå att kvaliteten på utmatningen beror starkt på promptens formulering. Att experimentera med olika promptstilar och strukturer kan ge förbättrade resultat. Dessutom är det viktigt att komma ihåg att Langchain stöder en mängd olika språkmodeller, och var och en har sina styrkor och svagheter. Att välja rätt modell för din specifika uppgift är avgörande. Slutligen är det viktigt att komma ihåg att användningen av dessa modeller medför kostnadsaspekter, eftersom tokenbearbetning direkt påverkar kostnaden för interaktioner.

Som demonstrerat i den steg-för-steg-guiden kan Langchain driva robusta tillämpningar, såsom det akademiska litteraturfrågesystemet. Med en växande användargemenskap och ökande betydelse i det öppna källandskapet lovar Langchain att bli ett avgörande verktyg för att utnyttja den fulla potentialen hos LLM-modeller som GPT-4.