Inginerie promptă de la zero la avansată cu Langchain în Python

Un aspect important al modelelor de limbaj mari (LLM) este numărul de parametri pe care aceste modele îi folosesc pentru învățare. Cu cât un model are mai mulți parametri, cu atât poate înțelege mai bine relația dintre cuvinte și expresii. Aceasta înseamnă că modelele cu miliarde de parametri au capacitatea de a genera diverse formate de text creative și de a răspunde întrebărilor deschise și provocatoare într-un mod informativ.

LLM-urile precum ChatGPT, care utilizează modelul Transformer, sunt competente în înțelegerea și generarea limbajului uman, făcându-le utile pentru aplicațiile care necesită înțelegerea limbajului natural. Cu toate acestea, ele nu sunt lipsite de limitările lor, care includ cunoștințe învechite, incapacitatea de a interacționa cu sistemele externe, lipsa de înțelegere a contextului și, uneori, generarea de răspunsuri care sună plauzibil, dar incorecte sau fără sens, printre altele.

Abordarea acestor limitări necesită integrarea LLM-urilor cu surse și capabilități externe de date, care pot prezenta complexități și necesită abilități extinse de codificare și manipulare a datelor. Acest lucru, împreună cu provocările de înțelegere a conceptelor AI și a algoritmilor complecși, contribuie la curba de învățare asociată cu dezvoltarea aplicațiilor folosind LLM.

Cu toate acestea, integrarea LLM-urilor cu alte instrumente pentru a forma aplicații bazate pe LLM ar putea redefini peisajul nostru digital. Potențialul unor astfel de aplicații este vast, incluzând îmbunătățirea eficienței și productivității, simplificarea sarcinilor, îmbunătățirea procesului decizional și furnizarea de experiențe personalizate.

În acest articol, vom aprofunda aceste probleme, explorând tehnicile avansate de inginerie promptă cu Langchain, oferind explicații clare, exemple practice și instrucțiuni pas cu pas despre cum să le implementăm.

Langchain, o bibliotecă de ultimă generație, oferă confort și flexibilitate în proiectarea, implementarea și reglarea solicitărilor. Pe măsură ce dezvăluim principiile și practicile ingineriei prompte, veți învăța cum să utilizați funcțiile puternice ale Langchain pentru a valorifica punctele forte ale modelelor SOTA Generative AI precum GPT-4.

Înțelegerea prompturilor

Înainte de a te scufunda în aspectele tehnice ale ingineriei prompte, este esențial să înțelegem conceptul de prompturi și semnificația lor.

A 'prompt' este o secvență de jetoane care sunt folosite ca intrare într-un model de limbaj, instruindu-l să genereze un anumit tip de răspuns. Prompturile joacă un rol crucial în direcţionarea comportamentului unui model. Acestea pot afecta calitatea textului generat și, atunci când sunt concepute corect, pot ajuta modelul să ofere rezultate perspicace, precise și specifice contextului.

Ingineria promptă este arta și știința de a proiecta indicații eficiente. Scopul este de a obține rezultatul dorit dintr-un model de limbă. Selectând și structurând cu atenție solicitările, se poate ghida modelul spre generarea de răspunsuri mai precise și mai relevante. În practică, aceasta implică reglarea fină a frazelor de intrare pentru a se adapta la pregătirea modelului și prejudecățile structurale.

Sofisticarea ingineriei prompte variază de la tehnici simple, cum ar fi alimentarea modelului cu cuvinte cheie relevante, până la metode mai avansate care implică proiectarea de prompturi complexe, structurate, care utilizează mecanica internă a modelului în avantajul său.

Langchain: Instrumentul prompt cu cea mai rapidă creștere

LangChain, lansat în octombrie 2022 de Harrison Chase, a devenit unul dintre cadrele open-source cele mai bine cotate pe GitHub în 2023. Oferă o interfață simplificată și standardizată pentru încorporarea modelelor de limbaj mari (LLM) în aplicații. De asemenea, oferă o interfață bogată în funcții pentru inginerie promptă, permițând dezvoltatorilor să experimenteze diferite strategii și să le evalueze rezultatele. Utilizând Langchain, puteți efectua sarcini de inginerie prompte mai eficient și mai intuitiv.

LangFlow servește ca o interfață de utilizator pentru orchestrarea componentelor LangChain într-o diagramă de flux executabilă, permițând prototiparea și experimentarea rapidă.

LangChain umple un gol crucial în dezvoltarea AI pentru mase. Permite o serie de aplicații NLP, cum ar fi asistenți virtuali, generatori de conținut, sisteme de răspunsuri la întrebări și multe altele, pentru a rezolva o serie de probleme din lumea reală.

În loc să fie un model sau un furnizor de sine stătător, LangChain simplifică interacțiunea cu diverse modele, extinzând capabilitățile aplicațiilor LLM dincolo de constrângerile unui simplu apel API.

Arhitectura LangChain

Componentele principale ale LangChain includ model I/O, șabloane de prompt, memorie, agenți și lanțuri.

Model I / O

LangChain facilitează o conexiune perfectă cu diverse modele de limbă, împachetându-le cu o interfață standardizată cunoscută sub numele de Model I/O. Acest lucru facilitează un comutator de model fără efort pentru optimizare sau performanță mai bună. LangChain acceptă diverși furnizori de modele de limbă, inclusiv OpenAI, Față îmbrățișată, Azuriu, Focuri de artificii, Și mai mult.

Șabloane prompte

Acestea sunt folosite pentru a gestiona și optimiza interacțiunile cu LLM-urile, oferind instrucțiuni sau exemple concise. Optimizarea prompturilor îmbunătățește performanța modelului, iar flexibilitatea acestora contribuie în mod semnificativ la procesul de introducere.

Un exemplu simplu de șablon prompt:

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="What are the recent advancements in the field of {subject}?")
print(prompt.format(subject="Natural Language Processing"))

Pe măsură ce avansăm în complexitate, întâlnim modele mai sofisticate în LangChain, cum ar fi modelul Reason and Act (ReAct). ReAct este un model vital pentru execuția acțiunii în care agentul atribuie o sarcină unui instrument adecvat, personalizează intrarea pentru aceasta și analizează rezultatul acesteia pentru a îndeplini sarcina. Exemplul Python de mai jos prezintă un model ReAct. Acesta demonstrează modul în care un prompt este structurat în LangChain, folosind o serie de gânduri și acțiuni pentru a raționa o problemă și a produce un răspuns final:

PREFIX = """Answer the following question using the given tools:"""
FORMAT_INSTRUCTIONS = """Follow this format:
Question: {input_question}
Thought: your initial thought on the question
Action: your chosen action from [{tool_names}]
Action Input: your input for the action
Observation: the action's outcome"""
SUFFIX = """Start!
Question: {input}
Thought:{agent_scratchpad}"""

Memorie

Memoria este un concept critic în LangChain, permițând LLM-urilor și instrumentelor să rețină informațiile în timp. Acest comportament cu stare îmbunătățește performanța aplicațiilor LangChain prin stocarea răspunsurilor anterioare, a interacțiunilor utilizatorului, a stării mediului și a obiectivelor agentului. Strategiile ConversationBufferMemory și ConversationBufferWindowMemory ajută la ținerea evidenței părților complete sau recente ale unei conversații. Pentru o abordare mai sofisticată, strategia ConversationKGMemory permite codificarea conversației ca un grafic de cunoștințe care poate fi reintrodus în solicitări sau utilizat pentru a prezice răspunsuri fără a apela LLM.

Agenți

Un agent interacționează cu lumea efectuând acțiuni și sarcini. În LangChain, agenții combină instrumente și lanțuri pentru executarea sarcinilor. Poate stabili o conexiune cu lumea exterioară pentru regăsirea informațiilor pentru a spori cunoștințele LLM, depășind astfel limitările lor inerente. Ei pot decide să transmită calculele unui calculator sau unui interpret Python, în funcție de situație.

Agenții sunt echipați cu subcomponente:

• Instrumente: Acestea sunt componente funcționale.
• toolkit: Colecții de unelte.
• Agenti executori: Acesta este mecanismul de execuție care permite alegerea între instrumente.

Agenții din LangChain urmează, de asemenea, modelul Zero-shot ReAct, unde decizia se bazează doar pe descrierea instrumentului. Acest mecanism poate fi extins cu memorie pentru a ține cont de istoricul complet al conversației. Cu ReAct, în loc să ceri unui LLM să completeze automat textul, îi poți solicita să răspundă într-o buclă de gândire/act/observare.

Lanţuri

Lanțurile, așa cum sugerează termenul, sunt secvențe de operații care permit bibliotecii LangChain să proceseze intrările și ieșirile modelului de limbaj fără probleme. Aceste componente integrale ale LangChain sunt alcătuite fundamental din legături, care pot fi alte lanțuri sau primitive, cum ar fi prompturi, modele de limbaj sau utilitare.

Imaginați-vă un lanț ca o bandă transportoare într-o fabrică. Fiecare pas de pe această centură reprezintă o anumită operație, care ar putea fi invocarea unui model de limbaj, aplicarea unei funcții Python unui text sau chiar solicitarea modelului într-un anumit mod.

LangChain își clasifică lanțurile în trei tipuri: lanțuri utilitare, lanțuri generice și lanțuri Combine Documents. Ne vom scufunda în lanțurile utilitare și generice pentru discuția noastră.

• Lanțuri utilitare sunt special concepute pentru a extrage răspunsuri precise din modele de limbaj pentru sarcini definite îngust. De exemplu, să aruncăm o privire la LLMMathChain. Acest lanț de utilitate permite modelelor de limbaj să efectueze calcule matematice. Acceptă o întrebare în limbaj natural, iar modelul de limbaj generează, la rândul său, un fragment de cod Python care este apoi executat pentru a produce răspunsul.
• Lanțuri generice, pe de altă parte, servesc ca elemente de bază pentru alte lanțuri, dar nu pot fi utilizate direct de sine stătătoare. Aceste lanțuri, cum ar fi LLMChain, sunt fundamentale și sunt adesea combinate cu alte lanțuri pentru a îndeplini sarcini complicate. De exemplu, LLMChain este folosit frecvent pentru a interoga un obiect model de limbaj prin formatarea intrării pe baza unui șablon prompt furnizat și apoi trecându-l modelului de limbă.

Implementarea pas cu pas a Prompt Engineering cu Langchain

Vă vom ghida prin procesul de implementare a ingineriei prompte folosind Langchain. Înainte de a continua, asigurați-vă că ați instalat software-ul și pachetele necesare.

Puteți profita de instrumente populare precum Docker, Conda, Pip și Poetry pentru a configura LangChain. Fișierele de instalare relevante pentru fiecare dintre aceste metode pot fi găsite în depozitul LangChain la https://github.com/benman1/generative_ai_with_langchain. Aceasta include a Dockerfile pentru Docker, a cerințe.txt pentru Pip, a pyproject.toml pentru poezie și a langchain_ai.yml dosar pentru Conda.

În articolul nostru vom folosi Pip, managerul de pachete standard pentru Python, pentru a facilita instalarea și gestionarea bibliotecilor terțe. Dacă nu este inclus în distribuția dvs. Python, puteți instala Pip urmând instrucțiunile de la https://pip.pypa.io/.

Pentru a instala o bibliotecă cu Pip, utilizați comanda pip install library_name.

Cu toate acestea, Pip nu gestionează mediile singur. Pentru a gestiona diferite medii, folosim instrumentul virtualenv.

În secțiunea următoare, vom discuta despre integrările modelelor.

Pasul 1: Configurarea Langchain

Mai întâi, trebuie să instalați pachetul Langchain. Folosim sistemul de operare Windows. Rulați următoarea comandă în terminalul dvs. pentru a o instala:

pip install langchain

Pasul 2: Importul Langchain și alte module necesare

Apoi, importați Langchain împreună cu alte module necesare. Aici, importăm și biblioteca de transformatoare, care este utilizată pe scară largă în sarcinile NLP.

import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Pasul 3: Încărcați modelul preantrenat

Deschide AI

OpenAI modelele pot fi interfațate convenabil cu biblioteca LangChain sau cu biblioteca client OpenAI Python. În special, OpenAI furnizează o clasă de încorporare pentru modelele de încorporare a textului. Două modele cheie LLM sunt GPT-3.5 și GPT-4, care diferă în principal în lungimea simbolului. Prețurile pentru fiecare model pot fi găsite pe site-ul OpenAI. În timp ce sunt mai multe modele sofisticate precum GPT-4-32K care au o acceptare mai mare a simbolurilor, disponibilitatea lor prin API este nu întotdeauna garantat.

Accesarea acestor modele necesită o cheie API OpenAI. Acest lucru se poate face prin crearea unui cont pe platforma OpenAI, configurarea informațiilor de facturare și generarea unei noi chei secrete.

import os
os.environ["OPENAI_API_KEY"] = 'your-openai-token'

După crearea cu succes a cheii, o puteți seta ca variabilă de mediu (OPENAI_API_KEY) sau o puteți transmite ca parametru în timpul instanțierii clasei pentru apelurile OpenAI.

Luați în considerare un script LangChain pentru a prezenta interacțiunea cu modelele OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# The LLM takes a prompt as an input and outputs a completion
prompt = "who is the president of the United States of America?"
completion = llm(prompt)

The current President of the United States of America is Joe Biden.

În acest exemplu, un agent este inițializat pentru a efectua calcule. Agentul preia o intrare, o sarcină simplă de adăugare, o procesează folosind modelul OpenAI furnizat și returnează rezultatul.

Fata îmbrățișată

Fata îmbrățișată este GRATUIT DE UTILIZARE Biblioteca Transformers Python, compatibilă cu PyTorch, TensorFlow și JAX și include implementări de modele precum OARET, T5, Etc

Hugging Face oferă, de asemenea, Hugging Face Hub, o platformă pentru găzduirea depozitelor de coduri, modele de învățare automată, seturi de date și aplicații web.

Pentru a utiliza Hugging Face ca furnizor pentru modelele dvs., veți avea nevoie de un cont și chei API, care pot fi obținute de pe site-ul lor. Tokenul poate fi disponibil în mediul dvs. ca HUGGINGFACEHUB_API_TOKEN.

Luați în considerare următorul fragment Python care utilizează un model open source dezvoltat de Google, modelul Flan-T5-XXL:

from langchain.llms import HuggingFaceHub

llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64},repo_id="google/flan-t5-xxl")
prompt = "In which country is Tokyo?"
completion = llm(prompt)
print(completion)

Acest script preia o întrebare ca intrare și returnează un răspuns, prezentând cunoștințele și capacitățile de predicție ale modelului.

Pasul 4: Inginerie de bază promptă

Pentru început, vom genera un prompt simplu și vom vedea cum răspunde modelul.

prompt = 'Translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

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

În fragmentul de cod de mai sus, oferim o solicitare pentru a traduce textul din engleză în franceză. Modelul de limbă încearcă apoi să traducă textul dat pe baza promptului.

Pasul 5: Inginerie avansată a promptului

În timp ce abordarea de mai sus funcționează bine, nu profită pe deplin de puterea ingineriei prompte. Să-l îmbunătățim prin introducerea unor structuri prompte mai complexe.

prompt = 'As a highly proficient French translator, translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

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

În acest fragment de cod, modificăm solicitarea pentru a sugera că traducerea este realizată de un „traducător francez foarte competent. Schimbarea promptului poate duce la traduceri îmbunătățite, deoarece modelul își asumă acum o persoană de expert.

Construirea unui sistem de întrebări și răspunsuri în literatura academică cu Langchain

Vom construi un sistem de întrebări și răspunsuri de literatură academică folosind LangChain, care poate răspunde la întrebări despre lucrările academice publicate recent.

În primul rând, pentru a configura mediul nostru, instalăm dependențele necesare.

pip install langchain arxiv openai transformers faiss-cpu

În urma instalării, creăm un nou blocnotes Python și importăm bibliotecile necesare:

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

Miezul sistemului nostru de întrebări și răspunsuri este capacitatea de a obține lucrări academice relevante legate de un anumit domeniu, aici luăm în considerare Procesarea limbajului natural (NLP), folosind baza de date academică arXiv. Pentru a realiza acest lucru, definim o funcție get_arxiv_data(max_results=10). Această funcție colectează cele mai recente rezumate de hârtie NLP din arXiv și le încapsulează în obiecte LangChain Document, folosind rezumatul ca conținut și ID-ul unic al intrării ca sursă.

Vom folosi API-ul arXiv pentru a prelua lucrări recente legate de NLP:

def get_arxiv_data(max_results=10):
    search = arxiv.Search(
        query="NLP",
        max_results=max_results,
        sort_by=arxiv.SortCriterion.SubmittedDate,
    )
   
    documents = []
   
    for result in search.results():
        documents.append(Document(
            page_content=result.summary,
            metadata={"source": result.entry_id},
        ))

    return documents

Această funcție preia rezumatele celor mai recente lucrări NLP din arXiv și le convertește în obiecte LangChain Document. Utilizăm rezumatul lucrării și ID-ul său unic de intrare (URL-ul către lucrare) ca conținut și, respectiv, sursă.

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

Să definim corpusul nostru și să setăm LangChain:

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

Cu sistemul nostru academic de întrebări și răspunsuri gata, îl putem testa punând o întrebare:

print_answer("What are the recent advancements in NLP?")

Rezultatul va fi răspunsul la întrebarea dvs., citând sursele din care au fost extrase informațiile. De exemplu:

Recent advancements in NLP include Retriever-augmented instruction-following models and a novel computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs).
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Puteți schimba cu ușurință modelele sau modifica sistemul în funcție de nevoile dvs. De exemplu, aici trecem la GPT-4, care sfârșește prin a ne oferi un răspuns mult mai bun și detaliat.

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

Recent advancements in Natural Language Processing (NLP) include the development of retriever-augmented instruction-following models for information-seeking tasks such as question answering (QA). These models can be adapted to various information domains and tasks without additional fine-tuning. However, they often struggle to stick to the provided knowledge and may hallucinate in their responses. Another advancement is the introduction of a computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). This approach utilizes a single-instruction, multiple-data (SIMD) abstraction of nonlinear programs (NLP) and employs a condensed-space interior-point method (IPM) with an inequality relaxation strategy. This strategy allows for the factorization of the KKT matrix without numerical pivoting, which has previously hampered the parallelization of the IPM algorithm.
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Un simbol în GPT-4 poate fi atât de scurt cât un caracter sau lung cât un cuvânt. De exemplu, GPT-4-32K poate procesa până la 32,000 de jetoane într-o singură rulare, în timp ce GPT-4-8K și GPT-3.5-turbo acceptă 8,000 și, respectiv, 4,000 de jetoane. Cu toate acestea, este important de reținut că fiecare interacțiune cu aceste modele vine cu un cost care este direct proporțional cu numărul de jetoane procesate, fie că este vorba de intrare sau de ieșire.

În contextul sistemului nostru de întrebări și răspunsuri, dacă o bucată de literatură academică depășește limita maximă de simboluri, sistemul nu va reuși să o proceseze în întregime, afectând astfel calitatea și caracterul complet al răspunsurilor. Pentru a rezolva această problemă, textul poate fi împărțit în părți mai mici care respectă limita de simboluri.

FAISS (Facebook AI Similarity Search) ajută la găsirea rapidă a celor mai relevante fragmente de text legate de interogarea utilizatorului. Acesta creează o reprezentare vectorială a fiecărei bucăți de text și folosește acești vectori pentru a identifica și a prelua bucățile cele mai asemănătoare cu reprezentarea vectorială a unei anumite întrebări.

Este important de reținut că, chiar și cu utilizarea unor instrumente precum FAISS, necesitatea de a împărți textul în bucăți mai mici din cauza limitărilor de simbol poate duce uneori la pierderea contextului, afectând calitatea răspunsurilor. Prin urmare, gestionarea atentă și optimizarea utilizării token-ului sunt cruciale atunci când lucrați cu aceste modele de limbaj mari.

 
pip install faiss-cpu langchain CharacterTextSplitter

După ce vă asigurați că bibliotecile de mai sus sunt instalate, rulați

 
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) # We can now use feed more 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))

search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())

chain = load_qa_with_sources_chain(OpenAI(temperature=0))

def print_answer(question):
    print(
        chain(
            {
                "input_documents": search_index.similarity_search(question, k=4),
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )

Odată cu codul complet, avem acum un instrument puternic pentru interogarea celei mai recente literaturi academice din domeniul NLP.

 
Recent advancements in NLP include the use of deep neural networks (DNNs) for automatic text analysis and natural language processing (NLP) tasks such as spell checking, language detection, entity extraction, author detection, question answering, and other tasks. 
SOURCES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1 

Concluzie

Integrarea modelelor de limbă mari (LLM) în aplicații a accelerat adoptarea mai multor domenii, inclusiv traducerea limbilor, analiza sentimentelor și regăsirea informațiilor. Ingineria promptă este un instrument puternic în maximizarea potențialului acestor modele, iar Langchain este lider în simplificarea acestei sarcini complexe. Interfața sa standardizată, șabloanele de prompt flexibile, integrarea robustă a modelului și utilizarea inovatoare a agenților și lanțurilor asigură rezultate optime pentru performanța LLM-urilor.

Cu toate acestea, în ciuda acestor progrese, există câteva sfaturi de reținut. Pe măsură ce utilizați Langchain, este esențial să înțelegeți că calitatea rezultatului depinde în mare măsură de formularea promptului. Experimentarea cu diferite stiluri și structuri prompte poate aduce rezultate îmbunătățite. De asemenea, rețineți că, deși Langchain acceptă o varietate de modele de limbaj, fiecare are punctele sale forte și punctele slabe. Alegerea celui potrivit pentru sarcina ta specifică este crucială. În cele din urmă, este important să ne amintim că utilizarea acestor modele vine cu considerații de cost, deoarece procesarea token-ului influențează direct costul interacțiunilor.

După cum se demonstrează în ghidul pas cu pas, Langchain poate alimenta aplicații robuste, cum ar fi sistemul Academic Literature Q&A. Cu o comunitate de utilizatori în creștere și o importanță în creștere în peisajul open-source, Langchain promite să fie un instrument esențial în valorificarea întregului potențial al LLM-urilor precum GPT-4.