Od zera do zaawansowanego inżynierii prompty z Langchain w Pythonie

Jednym z ważnych aspektów dużych modeli językowych (LLM) jest liczba parametrów, których używają do uczenia. Im więcej parametrów ma model, tym lepiej może zrozumieć relację między słowami i frazami. Oznacza to, że modele z miliardami parametrów mają możliwość generowania różnych kreatywnych formatów tekstu i odpowiadania na otwarte i trudne pytania w sposób informacyjny.

Modele LLM, takie jak ChatGPT, które wykorzystują model Transformer, są zdolne do zrozumienia i generowania języka ludzkiego, co sprawia, że są przydatne w aplikacjach wymagających zrozumienia języka naturalnego. Jednak mają one również ograniczenia, takie jak przestarzała wiedza, brak możliwości interakcji z zewnętrznymi systemami, brak zrozumienia kontekstu i czasami generowanie odpowiedzi, które brzmią prawdopodobnie, ale są niepoprawne lub nonsensowne, między innymi.

Nadrobienie tych ograniczeń wymaga integracji modeli LLM z zewnętrznymi źródłami danych i możliwościami, co może być skomplikowane i wymagać obszernych umiejętności programistycznych i zarządzania danymi. To, w połączeniu z wyzwaniami związanymi z zrozumieniem pojęć AI i złożonych algorytmów, przyczynia się do krzywej uczenia się związanej z tworzeniem aplikacji wykorzystujących modele LLM.

Niemniej, integracja modeli LLM z innymi narzędziami w celu utworzenia aplikacji wykorzystujących modele LLM może zrewolucjonizować nasz krajobraz cyfrowy. Potencjał takich aplikacji jest ogromny, w tym poprawa wydajności i produktywności, uproszczenie zadań, usprawnienie podejmowania decyzji i zapewnienie personalizowanych doświadczeń.

W tym artykule zagłębimy się w te problemy, eksplorując zaawansowane techniki inżynierii prompty z Langchain, oferując klarowne wyjaśnienia, praktyczne przykłady i krok-po-kroku instrukcje, jak je wdrożyć.

Langchain, biblioteka najnowszej generacji, przynosi wygodę i elastyczność w projektowaniu, wdrażaniu i dostosowywaniu prompty. Podczas gdy będziemy rozpakowywać zasady i praktyki inżynierii prompty, nauczysz się, jak wykorzystać potężne funkcje Langchain, aby wykorzystać zalety modeli generatywnych AI, takich jak GPT-4.

Zrozumienie prompty

Przed zanurzeniem się w technicznych aspektach inżynierii prompty, istotne jest zrozumienie pojęcia prompty i ich znaczenia.

Prompt to sekwencja tokenów używanych jako dane wejściowe do modelu językowego, nakazująca mu wygenerować określony typ odpowiedzi. Prompty odgrywają kluczową rolę w kierowaniu zachowaniem modelu. Mogą one wpłynąć na jakość wygenerowanego tekstu, a gdy są odpowiednio opracowane, mogą pomóc modelowi dostarczyć wglądu, dokładne i kontekstowo-specyficzne wyniki.

Inżynieria prompty to sztuka i nauka tworzenia skutecznych prompty. Celem jest wywołanie pożądanej odpowiedzi z modelu językowego. Poprzez staranne wybieranie i strukturyzowanie prompty, można nakierować model na generowanie bardziej dokładnych i istotnych odpowiedzi. W praktyce polega to na dostosowywaniu fraz wejściowych do upodobań i strukturalnych tendencji modelu.

Złożoność inżynierii prompty sięga od prostych technik, takich jak podawanie modelowi istotnych słów kluczowych, do bardziej zaawansowanych metod, które obejmują projektowanie złożonych, strukturalnych prompty, które wykorzystują wewnętrzną mechanikę modelu do jego korzyści.

Langchain: Najszybciej rozwijające się narzędzie prompty

LangChain, uruchomiony w październiku 2022 roku przez Harrisona Chase, stał się jednym z najwyżej ocenianych frameworków open-source na GitHub w 2023 roku. Oferuje uproszczony i standaryzowany interfejs do integrowania dużych modeli językowych (LLM) z aplikacjami. Zapewnia również funkcjonalny interfejs do inżynierii prompty, pozwalający deweloperom eksperymentować z różnymi strategiami i oceniać ich wyniki. Wykorzystując Langchain, możesz wykonywać zadania inżynierii prompty bardziej efektywnie i intuicyjnie.

LangFlow służy jako interfejs użytkownika do aranżowania składników LangChain w wykonalny diagram przepływu, umożliwiając szybkie prototypowanie i eksperymentowanie.

LangChain wypełnia istotną lukę w rozwoju AI dla mas. Umożliwia szereg aplikacji NLP, takich jak asystenci wirtualni, generatory treści, systemy odpowiedzi na pytania i wiele innych, aby rozwiązać szereg realnych problemów.

Zamiast być samodzielnym modelem lub dostawcą, LangChain upraszcza interakcję z różnymi modelami, rozszerzając możliwości aplikacji LLM poza ograniczenia prostego wywołania API.

Architektura LangChain

Główne składniki LangChain obejmują Model I/O, Prompt Templates, Memory, Agents i Chains.

Model I/O

LangChain ułatwia bezproblemową łączność z różnymi modelami językowymi, otaczając je standaryzowanym interfejsem zwanym Model I/O. Ułatwia to łatwą zmianę modelu w celu optymalizacji lub lepszej wydajności. LangChain obsługuje różnych dostawców modeli językowych, w tym OpenAI, HuggingFace, Azure, Fireworks i wiele innych.

Prompt Templates

Są one używane do zarządzania i optymalizacji interakcji z LLM. Optymalizacja prompty poprawia wydajność modelu, a ich elastyczność znacznie przyczynia się do procesu wejściowego.

Prosty przykład szablonu prompty:

<p>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"))</p>

Podczas gdy postępujemy w złożoności, spotykamy bardziej zaawansowane wzorce w LangChain, takie jak wzorzec Reason and Act (ReAct). ReAct jest istotnym wzorcem dla wykonania akcji, gdzie agent przydziela zadanie do odpowiedniego narzędzia, dostosowuje dane wejściowe i parsuje dane wyjściowe, aby osiągnąć zadanie. Poniższy przykład w Pythonie pokazuje wzorzec ReAct. Demonstruje, jak prompt jest strukturalizowany w LangChain, używając serii myśli i akcji, aby przemyśleć problem i wyprodukować ostateczną odpowiedź:

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}"""

Pamięć

Pamięć jest kluczowym pojęciem w LangChain, umożliwiającym LLM i narzędziom przechowywać informacje w czasie. To zachowanie stanowe poprawia wydajność aplikacji LangChain, przechowując poprzednie odpowiedzi, interakcje użytkownika, stan środowiska i cele agenta. Strategie ConversationBufferMemory i ConversationBufferWindowMemory pomagają śledzić pełne lub ostatnie części rozmowy. Dla bardziej zaawansowanego podejścia strategia ConversationKGMemory pozwala na zakodowanie rozmowy jako graf wiedzy, który może być wprowadzony z powrotem do prompty lub użyty do przewidywania odpowiedzi bez wywoływania LLM.

Agenci

Agent interaktywnie działa z otoczeniem, wykonując akcje i zadania. W LangChain agenci łączą narzędzia i łańcuchy do wykonania zadań. Może on ustanowić połączenie ze światem zewnętrznym w celu pobrania informacji, aby uzupełnić wiedzę LLM, tym samym pokonując ich wewnętrzne ograniczenia. Mogą one zdecydować o przekazaniu obliczeń do kalkulatora lub interpretera Pythona, w zależności od sytuacji.

Agenci są wyposażeni w podskładniki:

• Narzędzia: To są funkcjonalne składniki.
• Zestawy narzędzi: Zbiory narzędzi.
• Wykonawcy agentów: To jest mechanizm wykonawczy, który pozwala na wybór między narzędziami.

Agenci w LangChain również podążają za wzorcem Zero-shot ReAct, gdzie decyzja opiera się tylko na opisie narzędzia. Ten mechanizm może być rozszerzony o pamięć, aby wziąć pod uwagę pełną historię rozmowy. Z ReAct, zamiast prosić LLM o uzupełnienie tekstu, możesz nakazać mu odpowiedzieć w pętli myśl/akcja/obserwacja.

Łańcuchy

Łańcuchy, jak sama nazwa wskazuje, są sekwencjami operacji, które pozwalają bibliotece LangChain na płynne przetwarzanie danych wejściowych i wyjściowych modelu językowego. Te podstawowe składniki LangChain składają się zasadniczo z linków, które mogą być innymi łańcuchami lub prymitywami, takimi jak prompty, modele językowe lub narzędzia.

Wyobraź sobie łańcuch jako taśmę produkcyjną w fabryce. Każdy krok na tej taśmie reprezentuje określoną operację, która może być wywołaniem modelu językowego, zastosowaniem funkcji Pythona do tekstu lub nawet nakazaniem modelowi odpowiedzi w określony sposób.

LangChain klasyfikuje swoje łańcuchy na trzy typy: łańcuchy użytowe, łańcuchy ogólne i łańcuchy łączące dokumenty. Będziemy się zajmować łańcuchami użytowymi i ogólnymi.

• Łańcuchy użytowe są specjalnie zaprojektowane do wyodrębniania precyzyjnych odpowiedzi z modeli językowych dla wąsko określonych zadań. Na przykład, weźmy pod uwagę LLMMathChain. Ten łańcuch użytowy umożliwia modelom językowym wykonywanie obliczeń matematycznych. Akceptuje pytanie w języku naturalnym, a model językowy generuje wówczas fragment kodu Pythona, który jest następnie wykonywany w celu uzyskania odpowiedzi.
• Łańcuchy ogólne, z drugiej strony, służą jako bloki budulcowe dla innych łańcuchów, ale nie mogą być używane samodzielnie. Te łańcuchy, takie jak LLMChain, są podstawowe i często łączone z innymi łańcuchami w celu wykonania złożonych zadań. Na przykład, LLMChain jest często używany do zapytania obiektu modelu językowego, formatując dane wejściowe na podstawie podanego szablonu prompty i przekazując je do modelu językowego.

Krok-po-kroku wdrożenie inżynierii prompty z Langchain

Przewodzimy Cię przez proces wdrożenia inżynierii prompty przy użyciu Langchain. Przed kontynuowaniem upewnij się, że zainstalowałeś niezbędne oprogramowanie i pakiety.

Możesz skorzystać z popularnych narzędzi, takich jak Docker, Conda, Pip i Poetry, do konfigurowania LangChain. Odnośne pliki instalacyjne dla każdej z tych metod można znaleźć w repozytorium LangChain pod adresem https://github.com/benman1/generative_ai_with_langchain. Obejmuje to Dockerfile dla Dockera, requirements.txt dla PIPA, pyproject.toml dla Poetria i plik langchain_ai.yml dla Condy.

W naszym artykule użyjemy PIPA, standardowego menedżera pakietów Pythona, do ułatwienia instalacji i zarządzania bibliotekami zewnętrznymi. Jeśli nie jest on zawarty w Twojej dystrybucji Pythona, możesz zainstalować Pip, postępując zgodnie z instrukcjami na stronie https://pip.pypa.io/.

Aby zainstalować bibliotekę za pomocą PIPA, użyj polecenia pip install nazwa_biblioteki.

Jednak Pip nie zarządza środowiskami samodzielnie. Aby zarządzać różnymi środowiskami, używamy narzędzia virtualenv.

W następnej sekcji będziemy omawiać integrację modeli.

Krok 1: Konfigurowanie Langchain

Najpierw musisz zainstalować pakiet Langchain. Używamy systemu operacyjnego Windows. Uruchom następujące polecenie w terminalu, aby go zainstalować:

pip install langchain

Krok 2: Importowanie Langchain i innych niezbędnych modułów

Następnie importuj Langchain wraz z innymi niezbędnymi modułami. Tutaj importujemy również bibliotekę transformers, która jest szeroko stosowana w zadaniach NLP.

<p>import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Krok 3: Załaduj wstępnie wytrenowany model

Open AI

OpenAI models can be conveniently interfaced with the LangChain library or the OpenAI Python client library. Notably, OpenAI furnishes an Embedding class for text embedding models. Two key LLM models are GPT-3.5 and GPT-4, differing mainly in token length. Pricing for each model can be found on OpenAI’s website. While there are more sophisticated models like GPT-4-32K that have higher token acceptance, their availability via API is not always guaranteed.

Accessing these models requires an OpenAI API key. This can be done by creating an account on OpenAI’s platform, setting up billing information, and generating a new secret key.

<p>import os
os.environ["OPENAI_API_KEY"] = 'your-openai-token'</p>

After successfully creating the key, you can set it as an environment variable (OPENAI_API_KEY) or pass it as a parameter during class instantiation for OpenAI calls.

Consider a LangChain script to showcase the interaction with the OpenAI models:

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)

<p>The current President of the United States of America is Joe Biden.</p>

In this example, an agent is initialized to perform calculations. The agent takes an input, a simple addition task, processes it using the provided OpenAI model and returns the result.

Hugging

Hugging Face is a FREE-TO-USE Transformers Python library, compatible with PyTorch, TensorFlow, and JAX, and includes implementations of models like BERT, T5, etc.

Hugging Face also offers the Hugging Face Hub, a platform for hosting code repositories, machine learning models, datasets, and web applications.

To use Hugging Face as a provider for your models, you’ll need an account and API keys, which can be obtained from their website. The token can be made available in your environment as HUGGINGFACEHUB_API_TOKEN.

Consider the following Python snippet that utilizes an open-source model developed by Google (GOOGL ), the Flan-T5-XXL model:

from langchain.llms import HuggingFaceHub

<p>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)</p>

This script takes a question as input and returns an answer, showcasing the knowledge and prediction capabilities of the model.

Krok 4: Podstawowa inżynieria prompty

Na początek wygenerujemy prosty prompt i zobaczymy, jak model na niego zareaguje.

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')

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

In the above code snippet, we provide a prompt to translate English text into French. The language model then tries to translate the given text based on the prompt.

Krok 5: Zaawansowana inżynieria prompty

While the above approach works fine, it does not take full advantage of the power of prompt engineering. Let’s improve upon it by introducing some more complex prompt structures.

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')

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

In this code snippet, we modify the prompt to suggest that the translation is being done by a ‘highly proficient French translator. The change in the prompt can lead to improved translations, as the model now assumes a persona of an expert.

Budowanie systemu Q&A literatury akademickiej z Langchain

Będziemy budować system Q&A literatury akademickiej z LangChain, który może odpowiedzieć na pytania dotyczące ostatnio opublikowanych prac akademickich.

Po pierwsze, aby skonfigurować nasze środowisko, instalujemy niezbędne zależności.

pip install langchain arxiv openai transformers faiss-cpu

Następnie tworzymy nowy notes Pythona i importujemy niezbędne biblioteki:

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

Serdcem naszego systemu Q&A jest zdolność do pobierania istotnych prac akademickich związanych z określoną dziedziną, tutaj rozważamy Przetwarzanie Języka Naturalnego (NLP), przy użyciu bazy danych arXiv. Aby to osiągnąć, definiujemy funkcję get_arxiv_data(max_results=10). Ta funkcja gromadzi najnowsze podsumowania prac NLP z arXiv i zakoduje je w obiekty dokumentów LangChain, używając podsumowania jako zawartości i unikalnego identyfikatora wejścia jako źródła.

Będziemy używać API arXiv do pobierania ostatnich prac związanych z NLP:

<p>def get_arxiv_data(max_results=10):
search = arxiv.Search(
query="NLP",
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={"source": result.entry_id},
))</p>

return documents

<p-Ta funkcja pobiera podsumowania najnowszych prac NLP z arXiv i konwertuje je w obiekty dokumentów LangChain. Używamy podsumowania pracy i jej unikalnego identyfikatora (URL do pracy) jako zawartości i źródła, odpowiednio.

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

Teraz zdefiniujmy nasz korpus i skonfigurujmy LangChain:

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

Z naszym systemem Q&A gotowym do użycia, możemy go przetestować, zadając pytanie:

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

Wynik będzie odpowiedzią na Twoje pytanie, cytując źródła, z których informacje zostały pobrane. Na przykład:

<p>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

Możesz łatwo przełączyć się między modelami lub zmodyfikować system zgodnie z Twoimi potrzebami. Na przykład, tutaj zmieniamy na GPT-4, co daje nam znacznie lepszą i bardziej szczegółową odpowiedź.

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

<p>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</p>

Tokien w GPT-4 może być tak krótki, jak jeden znak, lub tak długi, jak jedno słowo. Na przykład, GPT-4-32K może przetwarzać do 32 000 tokenów w jednym przebiegu, podczas gdy GPT-4-8K i GPT-3.5-turbo obsługują odpowiednio 8 000 i 4 000 tokenów. Jednak należy pamiętać, że każda interakcja z tymi modelami wiąże się z kosztem, który jest bezpośrednio proporcjonalny do liczby przetworzonych tokenów, zarówno wejściowych, jak i wyjściowych.

W kontekście naszego systemu Q&A, jeśli fragment literatury akademickiej przekracza maksymalny limit tokenów, system nie będzie w stanie go przetworzyć w całości, co wpłynie na jakość i kompletność odpowiedzi. Aby rozwiązać ten problem, tekst można podzielić na mniejsze części, które spełniają limit tokenów.

FAISS (Facebook AI Similarity Search) (META ) pomaga w szybkim znalezieniu najbardziej istotnych fragmentów tekstu związanych z zapytaniem użytkownika. Tworzy reprezentację wektorową każdego fragmentu tekstu i używa tych wektorów do identyfikacji i pobierania fragmentów najbardziej podobnych do reprezentacji wektorowej danego pytania.

Jednak należy pamiętać, że nawet z użyciem narzędzi takich jak FAISS, konieczność podziału tekstu na mniejsze części z powodu limitu tokenów może czasami prowadzić do utraty kontekstu, co wpłynie na jakość odpowiedzi. Dlatego też staranne zarządzanie i optymalizacja użycia tokenów są kluczowe podczas pracy z dużymi modelami językowymi.

pip install faiss-cpu langchain CharacterTextSplitter

Po upewnieniu się, że powyższe biblioteki są zainstalowane, uruchom

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) # Możemy teraz użyć więcej danych
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(
{
"input_documents": search_index.similarity_search(question, k=4),
"question": question,
},
return_only_outputs=True,
)["output_text"]
)

Z kodem kompletnym, mamy teraz potężne narzędzie do zapytywania najnowszej literatury akademickiej w dziedzinie 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

Podsumowanie

Integracja dużych modeli językowych (LLM) z aplikacjami przyspieszyła ich przyjęcie w wielu dziedzinach, w tym tłumaczeniu języka, analizie nastrojów i wyszukiwaniu informacji. Inżynieria prompty jest potężnym narzędziem w maksymalizowaniu potencjału tych modeli, a Langchain jest liderem w uproszczeniu tego złożonego zadania. Jego standaryzowany interfejs, elastyczne szablony prompty, solidna integracja modeli i innowacyjne użycie agentów i łańcuchów zapewniają optymalne wyniki dla wydajności LLM.

Jednak pomimo tych postępów, istnieją pewne wskazówki, które należy pamiętać. Podczas korzystania z Langchain, istotne jest zrozumienie, że jakość wyjściowa zależy głównie od sformułowania prompty. Eksperymentowanie z różnymi stylami i strukturami prompty może prowadzić do lepszych wyników. Również pamiętaj, że Langchain obsługuje wiele modeli językowych, a każdy z nich ma swoje mocne i słabe strony. Wybór odpowiedniego modelu do Twojego konkretnego zadania jest kluczowy. Na koniec, pamiętaj, że korzystanie z tych modeli wiąże się z kosztami, ponieważ przetwarzanie tokenów wpływa bezpośrednio na koszt interakcji.

Jak pokazano w przewodniku krok po kroku, Langchain może napędzać solidne aplikacje, takie jak system Q&A literatury akademickiej. Z rosnącą społecznością użytkowników i rosnącym znaczeniem w krajobrazie open-source, Langchain obiecuje być kluczowym narzędziem w wykorzystaniu pełnego potencjału LLM, takich jak GPT-4.