LangChain to najnowocześniejsze i solidne narzędzie opracowane w celu wykorzystania mocy dużych modeli językowych (LLM).
Te LLM posiadają niezwykłe możliwości i mogą skutecznie radzić sobie z szeroką gamą zadań. Należy jednak zauważyć, że ich siła leży w ich ogólnym charakterze, a nie w dogłębnej wiedzy specjalistycznej. Jego popularność gwałtownie wzrosła od czasu wprowadzenia GPT-4.
Chociaż LLM doskonale radzą sobie z różnymi zadaniami, mogą napotkać ograniczenia, jeśli chodzi o udzielanie konkretnych odpowiedzi lub rozwiązywanie zadań wymagających głębokiej wiedzy dziedzinowej. Rozważ na przykład wykorzystanie LLM do odpowiadania na pytania lub wykonywania zadań w wyspecjalizowanych dziedzinach, takich jak medycyna lub prawo.
Chociaż LLM z pewnością może odpowiedzieć na ogólne zapytania dotyczące tych dziedzin, może mieć trudności z udzieleniem bardziej szczegółowych lub zniuansowanych odpowiedzi, które wymagają specjalistycznej wiedzy lub doświadczenia.
Dzieje się tak, ponieważ LLM są szkolone na ogromnych ilościach danych tekstowych z różnych źródeł, co umożliwia im poznanie wzorców, zrozumienie kontekstu i generowanie spójnych odpowiedzi. Jednak ich szkolenie zazwyczaj nie obejmuje zdobywania wiedzy specyficznej dla danej dziedziny lub wiedzy specjalistycznej w takim samym stopniu, jak w przypadku ekspertów w tych dziedzinach.
Dlatego chociaż LangChain w połączeniu z LLM może być nieocenionym narzędziem do szerokiego zakresu zadań, ważne jest, aby zdawać sobie sprawę, że w niektórych sytuacjach nadal może być konieczna głęboka wiedza specjalistyczna w danej dziedzinie. Eksperci-ludzcy posiadający specjalistyczną wiedzę mogą zapewnić niezbędną dogłębność, szczegółowe zrozumienie i wgląd w kontekst, które mogą wykraczać poza możliwości samych LLM.
Radzimy zajrzeć do dokumentów LangChain lub GitHub repozytorium dla dokładniejszego zrozumienia jego typowych przypadków użycia. Zdecydowanie zaleca się, aby uzyskać większy obraz tego pakietu.
Jak to działa?
Aby zrozumieć cel i działanie LangChain, rozważmy praktyczny przykład. Jesteśmy świadomi, że GPT-4 ma imponującą wiedzę ogólną i może udzielić rzetelnych odpowiedzi na szeroki zakres pytań.
Co jednak, jeśli chcemy konkretnych informacji z własnych danych, takich jak dokument osobisty, książka, plik PDF lub zastrzeżona baza danych?
LangChain pozwala nam łączyć duży model językowy jak GPT-4 do naszych własnych źródeł danych. Wykracza to poza zwykłe wklejenie fragmentu tekstu do interfejsu czatu. Zamiast tego możemy odwoływać się do całej bazy danych wypełnionej naszymi własnymi danymi.
Po uzyskaniu pożądanych informacji LangChain może pomóc nam w podjęciu określonych działań. Na przykład możemy polecić mu wysłanie wiadomości e-mail zawierającej określone szczegóły.
Aby to osiągnąć, stosujemy podejście potokowe z wykorzystaniem LangChain. Najpierw bierzemy dokument, który chcemy model języka do odniesienia i podzielić go na mniejsze części. Te fragmenty są następnie przechowywane jako osadzania, które są wektorowe reprezentacje tekstu w Vector Database.
Dzięki tej konfiguracji możemy tworzyć aplikacje modelu językowego, które działają zgodnie ze standardowym potokiem: użytkownik zadaje początkowe pytanie, które jest następnie wysyłane do modelu językowego. Reprezentacja wektorowa pytania jest używana do wyszukiwania podobieństw w Vector Database, pobierając odpowiednie fragmenty informacji.
Te fragmenty są następnie przekazywane z powrotem do modelu językowego, umożliwiając mu udzielenie odpowiedzi lub podjęcie pożądanej akcji.
LangChain ułatwia tworzenie aplikacji świadomych danych, ponieważ możemy odwoływać się do naszych własnych danych w sklepie wektorowym, oraz autentycznych, ponieważ mogą one podejmować działania wykraczające poza odpowiadanie na pytania. T
otwiera wiele praktycznych przypadków użycia, szczególnie w asyście osobistej, gdzie duży model językowy może obsługiwać takie zadania, jak rezerwacja lotów, przesyłanie pieniędzy lub pomoc w sprawach podatkowych.
Ponadto implikacje dla studiowania i uczenia się nowych przedmiotów są znaczące, ponieważ model językowy może odnosić się do całego programu nauczania i przyspieszyć proces uczenia się. Oczekuje się, że postępy te będą miały duży wpływ na kodowanie, analizę danych i naukę o danych.
Jedną z najbardziej ekscytujących perspektyw jest połączenie dużych modeli językowych z istniejącymi danymi firmy, takimi jak informacje o klientach lub dane marketingowe. Ta integracja z zaawansowanymi interfejsami API, takimi jak API Meta lub API Google, obiecuje wykładniczy postęp w analizie danych i nauce o danych.
Jak zbudować stronę internetową (wersja demonstracyjna)
Obecnie Langchain jest dostępny jako pakiety Python i JavaScript.
Możemy stworzyć demonstracyjną aplikację internetową wykorzystującą model Streamlit, LangChain i OpenAI GPT-3 do wdrożenia koncepcji LangChain.
Ale najpierw musimy zainstalować kilka zależności, w tym Streamlit, LangChain i OpenAI.
Wymagania wstępne
opływowy: Popularny pakiet Pythona do tworzenia aplikacji internetowych związanych z nauką o danych
OpenAI: Potrzebny jest dostęp do modelu językowego GPT-3 OpenAI.
Aby zainstalować te zależności, użyj następujących poleceń w cmd:
pip install streamlit
pip install langchain
pip install openai
Importuj pakiety
Zaczynamy od zaimportowania wymaganych pakietów, takich jak OpenAI, LangChain i Streamlit. Nasze łańcuchy modeli językowych są definiowane i wykonywane przy użyciu trzech klas z LangChain: LLMChain, SimpleSequentialChain i PromptTemplate.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Konfiguracja podstawowa
Strukturalna podstawa naszego projektu została następnie zbudowana przy użyciu składni Streamlit. Nadaliśmy aplikacji tytuł „What's TRUE: using Simple Sequential Chain” i zamieściliśmy link do repozytorium GitHub, które posłużyło jako inspiracja dla aplikacji.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Widżety frontowe
Skonfigurowaliśmy aplikację z kilkoma istotnymi informacjami, używając prostej składni Streamlit:
# 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")
Aby dodać widżety frontonu
Ponadto musimy udostępnić widżet do wprowadzania danych, aby umożliwić naszym użytkownikom wprowadzanie dowolnych pytań.
# 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?",
)
Wszystko gotowe! Łańcuchy już działają!
Zatrudniamy różne łańcuchy operacji wraz z SimpleSequentialChain
aby odpowiedzieć na zapytanie użytkownika. Łańcuchy są wykonywane w następującej kolejności, gdy użytkownik wybierze "Tell me about it"
przycisk:
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
: który jest pierwszym krokiem w naszym potoku, odbiera pytanie użytkownika jako dane wejściowe i wyjściowe. Zapytanie użytkownika służy jako szablon łańcucha.- Opierając się na oświadczeniu powiązanym z pytaniem,
assumptions_chain
generuje wypunktowaną listę założeń na podstawie danych wyjściowych programuquestion_chain
jako wejście. TheLLMChain
iOpenAI
Do skonstruowania instrukcji użyto modelu z LangChain. Zadaniem użytkownika jest stworzenie listy założeń, które zostały poczynione w celu wyprodukowania wypowiedzi na podstawie szablonu dla tego łańcucha. - Na podstawie wyników z
question_chain
iassumptions_chain
Thefact_checker_chain
generuje listę twierdzeń w postaci wypunktowanych punktów. Roszczenia są tworzone przy użyciuOpenAI
model iLLMChain
z LangChaina. Użytkownik ma za zadanie określić, czy każde twierdzenie jest dokładne, czy niepoprawne, i uzasadnić te, które są. - Połączenia
answer_chain
korzysta z wyjść zquestion_chain
,assumptions_chain
,fact_checker_chain
jako dane wejściowe do stworzenia odpowiedzi na pytanie użytkownika przy użyciu danych wygenerowanych przez wcześniejsze łańcuchy. Szablon tego łańcucha żąda, aby użytkownik odpowiedział na pierwsze zapytanie, korzystając z utworzonych faktów. - Aby zapewnić ostateczną odpowiedź na zapytanie użytkownika w oparciu o informacje wygenerowane przez wcześniejsze łańcuchy, integrujemy te łańcuchy z całym łańcuchem. Po zakończeniu łańcuchów używamy
st.success()
aby pokazać użytkownikowi rozwiązanie.
Wnioski
Możemy po prostu łączyć ze sobą różne akcje modeli językowych, aby tworzyć bardziej skomplikowane potoki za pomocą SimpleSequentialChain
moduł LangChaina. W przypadku szerokiej gamy aplikacji NLP, w tym chatbotów, systemów pytań i odpowiedzi oraz narzędzi do tłumaczenia językowego, może to być bardzo pomocne.
Doskonałość LangChain polega na zdolności do abstrakcji, co pozwala użytkownikowi skoncentrować się na bieżącym zagadnieniu, a nie na specyfice modelowania języka.
LangChain sprawia, że proces tworzenia zaawansowanych modeli językowych jest bardziej przyjazny dla użytkownika, oferując wstępnie wytrenowane modele i wybór szablonów.
Daje ci możliwość precyzyjnego dostrojenia modeli językowych przy użyciu własnych danych, co ułatwia dostosowanie modeli językowych. Umożliwia to opracowanie bardziej precyzyjnych, specyficznych dla domeny modeli, które dla danego zadania przewyższają wyszkolone modele.
Połączenia SimpleSequentialChain
Moduł i inne cechy LangChain sprawiają, że jest to skuteczne narzędzie do szybkiego tworzenia i wdrażania zaawansowanych systemów NLP.
Dodaj komentarz