Első lépések a LangChainben: A végső útmutató kezdőknek (1. rész)

Mi az a LangChain?

A „LangChain” egy nagy nyelvi modellek (LLM) köré épülő keretrendszer. Integrációkat tartalmaz a rendszerek és eszközök széles skálájával. A LangChain lehetővé teszi a különböző moduláris komponensek, például a PromptTemplate és az LLM láncolását, hogy szekvenciát vagy láncot hozzanak létre, amely bemenetet vesz, feldolgozza és választ generál. Ez sokoldalú eszközzé teszi, amely sokféle környezetben és alkalmazásban használható. Nyílt forráskódú projektként a LangChain profitál a fejlesztők nagy közösségének hozzájárulásából és hozzájárulásából.

A LangChain hét modult foglal magában: Prompts, Models, Memory, Indexes, Chains, Agents és Callbacks. Ebben a cikkben ezek közül hármat szeretnék leírni: promptokat, modelleket és memóriát.

Megjegyzés: A LangChain OpenAI-burkolóval való használatához telepítenünk és importálnunk kell LangChain és OpenAI csomagokat, valamint létre kell hoznunk OpenAI API-kulcsot. Kérjük, olvassa el a legutóbbi bejegyzésemet, hogy ellenőrizze, hogyan hozható létre az API-kulcs.

#install the LangChain package
pip install langchain
# install the OpenAI package
pip install openai
# import langchain
import langchain
#import openai
import openai

# set openai_api_key as an environment variable 
import os
os.environ["OPENAI_API_KEY"] = ""

Kéri

A felszólítás arra a nyilatkozatra vagy kérdésre utal, amelyet az LLM-nek küldtek információkérésre. Általában ez egy rövid szövegrészlet vagy néhány mondat, amely közvetíti a felhasználó szándékát vagy lekérdezését.

A Prompts modul felelős a promptok létrehozásáért és kezeléséért.

A LangChain leegyszerűsíti a promptok létrehozását a PromptTemplate megadásával. Ez a sablon felfogható a promptok formátumának vagy mintájának, helyőrzőkkel, amelyeket meg lehet tölteni konkrét részletekkel vagy példákkal. Ez a megközelítés lehetővé teszi a promptok újrafelhasználását, ami különösen fontossá válik a prompt hosszának növekedésével.
Kétféle prompt sablon létezik: szöveges prompt sablonok és csevegési prompt sablonok.

A Szöveges felszólító sablonok karakterláncot használnak bevitelként.

from langchain.prompts import PromptTemplate

# create a string template with `sample_text` input variable
template = """You will provided with the sample text. \
Your task is to rewrite the text to be gramatically correct. \
Sample text: ```{sample_text}``` \
Output: 
"""
# create a prompt template using above-defined template string 
prompt_template = PromptTemplate.from_template(
    template=template
)
# specify the `sample_text` variable
sample_text = "Me likes cats not dogs. They jumps high so much!"
# generate a final prompt by passing `sample_text` variable
final_prompt = prompt_template.format(
    sample_text=sample_text
)
print(final_prompt)

A csevegési felszólítási sablonok a csevegési üzenetek listáját veszik be bevitelként. Minden csevegőüzenet egy szerepkörhöz van társítva (pl. „MI, ember vagy rendszer”).

from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate, ChatPromptTemplate

# create a string template for a System role with two input variable: `output_language` and `max_words`
system_template = """You will provided with the sample text. \
Your task is to translate the text into {output_language} language \
and summarize the translated text in at most {max_words} words. \ 
"""
# create a prompt template for a System role
system_message_prompt_template = SystemMessagePromptTemplate.from_template(
    system_template)
# create a string template for a System role with `sample_text` input variable
human_template = "{sample_text}"
# create a prompt template for a Human role
human_message_prompt_template = HumanMessagePromptTemplate.from_template(human_template)
# create chat prompt template out of one or several message prompt templates
chat_prompt_template = ChatPromptTemplate.from_messages(
    [system_message_prompt_template, human_message_prompt_template])
# generate a final prompt by passing all three variables (`output_language`,  `max_words`, `sample_text`)
final_prompt = chat_prompt_template.format_prompt(output_language="English", max_words=15,
                          sample_text="Estoy deseando que llegue el fin de semana.").to_messages()
print(final_prompt)

Modellek

A Models modul a LangChain alapvető összetevője. Kétféle modellből áll: nyelvi modellekből és szövegbeágyazási modellekből.

Nyelvi modellek

A nyelvi modellek különösen alkalmasak szöveggenerálási feladatokra. A nyelvi modelleknek két változata létezik: LLM-ek és Chat-modellek. Ezek a modellek egy szöveges karakterláncot vesznek be bevitelként és egy szöveges karakterláncot is adnak ki.

from langchain.llms import OpenAI

# initialize GPT-3.5 model, remember that temperature parameter defines randomness of the response
llm = OpenAI(model_name="gpt-3.5-turbo", temperature=0)
template = """You will provided with the sample text. \
Your task is to rewrite the text to be gramatically correct. \
Sample text: ```{sample_text}``` \
Output: 
"""
prompt_template = PromptTemplate.from_template(
    template=template
)
sample_text = "Me likes cats not dogs. They jumps high so much!"
final_prompt = prompt_template.format(
    sample_text=sample_text
)
# generate the output by calling GPT model and passing the prompt
completion = llm(final_prompt)
print(completion)

Chat modellek

A csevegési modelleket nyelvi modellek támogatják. A chat-üzeneteket bemenetként veszik, kimenetként pedig a chat-üzeneteket adják vissza. Ez különösen alkalmassá teszi őket társalgási AI alkalmazásokhoz.

from langchain.chat_models import ChatOpenAI
from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate, ChatPromptTemplate

# initialize ChatGPT model
chat = ChatOpenAI(temperature=0)
system_template = """You will provided with the sample text. \
Your task is to translate the text into {output_language} language \
and summarize the translated text in at most {max_words} words. \ 
"""
system_message_prompt_template = SystemMessagePromptTemplate.from_template(
    system_template)
human_template = "{sample_text}"
human_message_prompt_template = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt_template = ChatPromptTemplate.from_messages(
    [system_message_prompt_template, human_message_prompt_template])
final_prompt = chat_prompt_template.format_prompt(output_language="English", max_words=15,
                          sample_text="Estoy deseando que llegue el fin de semana.").to_messages()
# generate the output by calling ChatGPT model and passing the prompt
completion = chat(final_prompt)
print(completion)

Szövegbeágyazási modellek

A szövegbeágyazás a szöveges adatok numerikus formátumban történő megjelenítésére szolgál, amely érthető és feldolgozható az ML modellekkel. Számos NLP feladatban használják, például hasonlóságmérésben és szövegosztályozásban.

A szövegbeágyazási modellek szöveget vesznek bevitelként, és visszaadják a lebegési listát. Az alábbi példában az OpenAI beágyazási modell körül burkolóelemet fogunk használni.

from langchain.embeddings import OpenAIEmbeddings

# initialize OpenAI embedding model
embeddings = OpenAIEmbeddings(model = "text-embedding-ada-002")
# create a text to be embedded
text = "It is imperative that we work towards sustainable practices, reducing waste and conserving resources."
# generate embedding by calling OpenAI embedding model and passing the text
embedded_text = embeddings.embed_query(text)
print(embedded_text)

memória

A LangChain Memory modulját úgy tervezték, hogy a felhasználó nyelvi modellel való interakciója során megtartsa az állapot fogalmát. A hontalanság azt jelenti, hogy a nyelvi modell minden bejövő lekérdezést függetlenül kezel. Bizonyos alkalmazásokban, például a chatbotokban azonban kulcsfontosságú, hogy emlékezzünk a korábbi interakciókra mind rövid, mind hosszú távú szinten. A teljes beszélgetés kontextusként való átadása a nyelvi modellnek nem optimális megoldás, mivel a tokenek száma gyorsan megnőhet, és esetleg túllépheti a megengedett határt. A Memory modul megkönnyíti a beszélgetési előzmények tárolását, és megbirkózik ezekkel a kihívásokkal.

Az egyik legegyszerűbb memóriatípus a ConversationBufferMemory, amely egyszerűen tárolja az üzeneteket, majd kibontja őket egy változóban.

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
# saving conversation
memory.save_context({"input": "Describe LSTM"}, {
                    "output": "LSTM is a type of recurrent neural network architecture that is widely used for sequential and time series data processing."})
# retrieving conversation from a memory
memory.load_memory_variables({})

A ConversationBufferMemory mellett a LangChain számos más típusú Memory típust is kínál. Kérjük, olvassa el a LangChain dokumentációt, hogy megtudja, melyik memóriatípus felel meg legjobban az Ön speciális igényeinek.

Ha nem ismeri a vektoros adatbázisokat, javasoljuk, hogy olvassa el a róluk szóló kiváló fenyőtoboz-cikket.

Érdemes megemlíteni, hogy többféle memória használható egyszerre. Ezenkívül lehetőség van a beszélgetést egy adatbázisba menteni hosszú távú tárolás és visszakeresés céljából.

Következtetés

A LangChain egy hatékony keretrendszer, amely leegyszerűsíti az AI-alkalmazások fejlesztését. Ebben a cikkben három kulcsfontosságú LangChain modulról adunk áttekintést: Prompt, Model és Memory. A következő cikkben a fennmaradó modulokba fogunk beleásni, bővítve a LangChain teljes képességeinek megértését.