[자연어처리] LangChain — Prompt Template (medium 번역)

개요

https://tonylixu.medium.com/langchain-prompt-template-0359d96090c5

LangChain — Prompt Template

개인적 공부를 위해 위 글을 단순 번역한 글입니다.

---

What is a Prompt

• A “prompt” is a carefully crafted input that is given to a language model to elicit a specific desired response. Prompts are essentially instructions or questions designed to guide the model’s output in a certain direction. They play a crucial role in interacting with models like GPT (Generative Pre-trained Transformer) and other AI language systems.
  • 프롬프트는 원하는 대답을 유도하기 위해 신중하게 설계된 입력이다.
  • 프롬프트는 본질적으로 모델의 출력을 특정 방향으로 이끌기 위한 지침이나 질문으로 구성되어 있다.
  • 이것은 GPT 및 기타 AI 언어 시스템과 상호 작용할 때 중요한 역할을 한다.
• A basic prompt structure looks like:

• Instructions: Informs the model about the general task at hand and how to approach it, such as how to utilize provided external information, process queries, and structure the output. This is typically a more constant section within a prompt template. A common use case involves telling the model “You are a useful XX assistant,” prompting it to take its role more seriously.
  • 지시사항: 모델에게 일반적인 접근 방법에 대해 알려준다.
    • 주어진 외부 정보를 활용하는 방법, 질문을 처리하는 방법, 출력을 구조화하는 방법 등
  • 일반적으로 프롬프트 템플릿에서 고정된 부분이다.
  • 기본적인 사용 예시는 "당신은 유용한 XX 어시시스턴트입니다."라고 알리고 모델에게 그 역할을 더욱 심각하게 받아들이도록 하는 것이다.

• Context: It acts as an additional source of knowledge for the model. This information can be manually inserted into the prompt, retrieved through vector database searches, or brought in through other methods (like calling APIs, using calculators, etc.). A common application is to pass knowledge obtained from a vector database search to the model as context.
  • 맥락: 모델에 대한 추가적인 지식의 원천으로 작용한다.
  • 이 정보는 수동으로 프롬프트에 삽입되거나 벡터 데이터베이스 검색을 통해 가져오거나 다른 방식(API 호출, 계산기 사용 등)을 통해 가져올 수 있다.
  • 기본적인 사용 예시는 벡터 데이터베이스 검색을 통해 얻은 지식을 모델에게 맥락으로 전달하는 것이 있다.

• Prompt Input: It usually represents the specific question or task for the large model to address. This part could actually be merged with the “Instruction” section, but separating it into an independent component makes the structure more organized and the template easier to reuse. It is typically passed as a variable to the prompt template before invoking the model to form a specific prompt.
  • 프롬프트 입력: 일반적으로 모델이 다루어야 할 구체적인 질문이나 작업을 나타낸다.
  • 이 부분은 사실 "지시사항" 섹션과 합칠 수 있지만, 독립적인 요소로 분리하면 구조가 더 조직적이고 템플릿을 재사용하기가 쉽다.
  • 이것은 주로 모델을 호출하기 전에 프롬프트 템플릿에 변수로 전달되어 구체적인 프롬프트를 형성한다.

• Output Indicator: It marks the beginning of the text to be generated. It’s similar to writing “Solution:” on a math test in childhood, signaling the start of your answer. If generating Python code, the word “import” might be used to signal the model to start writing Python code (as most Python scripts begin with imports). This part is often superfluous when conversing with ChatGPT, but in LangChain, agents often use a “Thought:” as a lead-in, indicating the model to start outputting its reasoning.
  • 출력 지시사항: 생성될 텍스트의 시작을 표시한다.
  • 이는 수학 시험에서 "해결책: "이라고 쓰는 것과 유사하게 답변을 시작하는 신호를 나타낸다.
  • Python 코드를 생성하는 경우 "import"라는 단어가 사용될 수 있으며 이는 모델에게 Python 코드 작성을 시작하도록 하는 신호로 사용될 수 있다. (대부분의 Python 스크립트는 import로 시작되기 때문에)
  • 이 부분은 ChatGPT와 대화할 때 종종 불필요하지만 Langchain에서는 에이전트가 자신의 추론을 출력하기 시작하도록 하는 선언으로 "Thought: "를 사용하는 경우가 많다.

---

Types of Prompt Templates in LangChain

• LangChain offers two fundamental types of templates: String (StringPromptTemplate) and Chat (BaseChatPromptTemplate), from which various specialized prompt templates are constructed:
  • LangChain은 두 가지 기본 유형의 템플릿을 제공한다.
  • 문자열(StringPromptTemplate)과 채팅(BaseChatPromptTemplate).
  • 이들을 기반으로 다양한 전문화된 프롬프트 템플릿이 구성된다.

• To import these templates in LangChain, you can:
  • LangChain에서 이 템플릿들을 임포트하기 위해서는 다음과 같이 할 수 있다.

from langchain.prompts.prompt import PromptTemplate
from langchain.prompts import FewShotPromptTemplate
from langchain.prompts.pipeline import PipelinePromptTemplate
from langchain.prompts import ChatPromptTemplate
from langchain.prompts import (
    ChatMessagePromptTemplate,
    SystemMessagePromptTemplate,
    AIMessagePromptTemplate,
    HumanMessagePromptTemplate,
)

---

PromptTemplate

A simple example:

from langchain import prompts

template = """\
You are a business consulting advisor.
Can you suggest a good name for an e-commerce company that sells {product}?
"""
prompt = prompts.PromptTemplate.from_template(template)

print(prompt.format(product="toy"))

• The primary function of this program is to generate prompts tailored to various scenarios, offering suggestions for company names based on a product or service defined by the user.
  • 이 프로그램의 주요 기능은 사용자가 정의한 제품 또는 서비스를 기반으로 회사 이름에 대한 제안을 생성하는 것이다.
• In the process described above, one convenient aspect of the templates in LangChain is that the from_template method can automatically extract variable names (such as product) from the input string without the need for explicit specification. Consequently, product in the program becomes an automatic parameter within the format method.
  • 위에서 설명한 프로세스에서 LangChain의 템플릿의 편리한 측면 중 하나는 from_template 메서드가 명시적인 지정 없이 입력 문자열에서 변수 이름(예: 제품)을 자동으로 추출할 수 있다는 것이다. 결과적으로 프로그램에서는 format 메서드 내에서 product가 자동 매개변수로 사용된다.
• you also have the option to manually specify input_variables through the constructor of the prompt template class when creating the template, as illustrated in the following example:
  • 또한 템플릿을 생성할 때 템플릿 클래스의 생성자를 통해 input_variables를 수동으로 지정할 수 있는 옵션이 있다. 다음 예시에서 설명한 것처럼.

prompt = PromptTemplate(
    input_variables=["product", "market"], 
    template="You are a business consulting advisor. For a company focusing on selling {product} in the {market} market, what name would you recommend?"
)
print(prompt.format(product="flowers", market="middle"))

---

ChatPromptTemplate

• For chat models like OpenAI’s ChatGPT, LangChain also offers a range of templates, each featuring specific roles. The following code demonstrates the various message roles in OpenAI’s Chat Model.
  • ChatGPT와 같은 채팅 모델을 위해 LangChain은 특정 역할을 갖춘 다양한 템플릿을 제공한다.
  • 다음 코드는 OpenAI의 채팅 모델에서 다양한 메시지 역할을 보여준다.
• For example:

import openai

openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
        {"role": "system", "content": "You are an informed sports assistant."},
        {"role": "user", "content": "Tell me about the 2022 FIFA World Cup."},
        {"role": "assistant", "content": "The 2022 FIFA World Cup is scheduled to be held in Qatar."},
        {"role": "user", "content": "What teams are considered favorites?"}
    ]
)

• The format specification for messages transmitted to gpt-3.5-turbo and GPT-4 by OpenAI is as follows:
  • OpenAI에서 gpt-3.5-turbo 및 gpt-4로 전송되는 메시지의 형식 지정은 다음과 같다.
• Messages must be an array of message objects, each with a role (system, user, or assistant) and content. The conversation can be as short as a single message or involve multiple exchanges.
  • 메시지는 역할(system, user, assistant)과 내용을 갖는 배열이어야 한다.
  • 대화는 단일 메시지일 수도 있고 여러 교환을 포함할 수도 있다.
• Typically, a dialogue starts with a system message for formatting, followed by alternating user and assistant messages.
  • 일반적으로 대화는 서식을 위한 시스템 메시지로 시작하고, 그 뒤로는 번갈아가면서 사용자 및 어시스턴트 메시지가 이어진다.
• System messages help to set the behavior of the assistant. For instance, you can modify the assistant’s personality or provide specific instructions on how it should behave throughout the conversation. However, note that system messages are optional, and the behavior of models without system messages may be similar to using a generic message, such as “You are a helpful assistant.”
  • 시스템 메시지는 어시스턴트의 행동을 설정하는 데 도움을 준다.
  • 예를 들어, 어시스턴트의 성격을 수정하거나 대화 전반에 걸쳐 어떻게 행동해야 하는지에 대한 특정 지침을 제공할 수 있다.
  • 하지만, 시스템 메시지는 선택적이라는 걸 주의해라.
  • 시스템 메시지가 없는 모델의 행동은 "당신은 도움이 되는 어시스턴트이다"와 같은 일반적인 메시지를 사용하는 것과 유사할 것이다.
• User messages provide requests or comments for the assistant to respond to. Assistant messages store previous assistant responses but can also be written by you to provide examples of the desired behavior.
  • 사용자 메시지는 어시스턴트에게 응답할 요청이나 코멘트를 제공한다.
  • 어시스턴트 메시지는 이전 어시스턴트 응답을 저장하지만, 원하는 행동의 예시를 제공하기 위해 직접 작성될 수도 있다.
• The series of ChatPromptTemplate templates in LangChain are designed in alignment with this range of roles. For example:
  • LangChain의 ChatPromptTemplate 시리즈는 이러한 역할 범위에 맞추어 설계되어있다.

# Import chat message class templates
from langchain.prompts import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)

# Building the template
template = "You are a creative marketing expert, tasked with brainstorming advertising strategies for {product} companies."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "Our focus is on {product_detail}, targeting the youth market."
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
prompt_template = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])

# Formatting the prompt messages
prompt = prompt_template.format_prompt(product="tech gadgets", product_detail="eco-friendly smart watches").to_messages()

# Calling the model with the prompt to generate results
from langchain.chat_models import ChatOpenAI
chat = ChatOpenAI()
result = chat(prompt)
print(result)

• Outputs:

content='xxxxxx' 
additional_kwargs={} 
example=False

---

FewShotPromptTemplate

• The concept of FewShot, or few-shot learning, is a crucial aspect of prompt engineering. It aligns with the second guideline in OpenAI’s prompt engineering recommendations — providing the model with references or examples.
  • few-shot learning의 개념은 프롬프트 엔지니어링의 중요한 측면이다.
  • 이는 OpenAI의 프롬프트 엔지니어링 권고사항 중 두 번째 지침과 일치하며, 모델에 참조 자료나 예제를 제공한다.
• The concepts of Few-Shot (few examples), One-Shot (single example), and the corresponding Zero-Shot (no examples) originate from machine learning. The ability of machine learning models to learn new concepts or categories with minimal or even no examples is highly valuable for many real-world problems, as acquiring a large amount of labeled data is often not feasible.
  • Few-Shot, One-shot,그리고 Zero-shot의 개념은 기계 학습에서 기원된다.
  • 기계 학습 모델이 최소한이나 아예 없는 예제로 새로운 개념이나 범주를 학습할 수 있는 능력은 많은 현실 세계의 문제에 대해 매우 가치가 있다.
  • 대량의 레이블이 달린 데이터를 확보하는 것은 종종 실현 가능하지 않기 때문이다.

Let’s create some sample inputs

samples = [
  {
    "toy_type": "Building Blocks",
    "occasion": "Learning",
    "ad_copy": "Building blocks, perfect for sparking creativity, are the ideal choice for educational play."
  },
  {
    "toy_type": "Teddy Bear",
    "occasion": "Comfort",
    "ad_copy": "Teddy bears, a cuddly companion, offer comfort and friendship to children."
  },
  {
    "toy_type": "Lego sports car",
    "occasion": "Birthday",
    "ad_copy": "Lego sport cars bring thrilling adventures to playtime, perfect for a birthday gift."
  },
  {
    "toy_type": "Puzzle",
    "occasion": "Brain Teasing",
    "ad_copy": "Puzzles challenge the mind and offer hours of problem-solving fun for all ages."
  }

Based on the above samples, let’s create a template

from langchain.prompts.prompt import PromptTemplate
template = "Toy Type: {toy_type}\nOccasion: {occasion}\nAd Copy: {ad_copy}"
prompt_sample = PromptTemplate(input_variables=["toy_type", "occasion", "ad_copy"], 
                               template=template)
print(prompt_sample.format(**samples[0]))

• In this step, we have created a PromptTemplate object. This object generates prompts based on specified input variables and a template string. Here, the input variables include “toy_type”, “occasion”, and “ad_copy”.
  • 이 단계에서는 PromptTemplate 객체를 생성했다.
  • 이 객체는 지정된 입력 변수와 템플릿 문자열을 기반으로 프롬프트를 생성한다.
  • 여기서 입력 변수에는 "toy_type", "occasion", "ad_copy"가 포함되어 있다.
• The template is a string containing variable names enclosed in curly braces, which are replaced by the corresponding variable values. With this, we have transformed the example format from the dictionary into a prompt template, creating usable LangChain prompts. For instance, I used data from samples[0] to replace the variables in the template, resulting in a complete prompt.
  • 템플릿은 중괄호로 둘러싸인 변수 이름을 포함한 문자열이며, 이는 해당 변수 값으로 대체된다.
  • 이를 통해 사전 형식의 예제를 프롬프트 템플릿으로 변환하고, 사용 가능한 LangChain 프롬프트를 생성했다.
  • 예를 들어, sample[0]의 데이터를 사용하여 템플릿 내의 변수를 대체하여 완전한 프롬프트를 생성했다.

Create FewShotPromptTemplate

• Next, by utilizing the prompt_sample created in the previous step and all examples from the samples list, we create a FewShotPromptTemplate object to generate more complex prompts.
  • 다음으로, 이전 단계에서 생성한 prompt_sample 및 samples 목록의 모든 예제를 활용하여 더 복잡한 프롬프트를 생성할 수 있는 FewShotPromptTemplate 객체를 만든다.

# 3. Create a FewShotPromptTemplate object
from langchain.prompts.few_shot import FewShotPromptTemplate
prompt = FewShotPromptTemplate(
    examples=samples,
    example_prompt=prompt_sample,
    suffix="Toy Type: {toy_type}\nOccasion: {occasion}",
    input_variables=["toy_type", "occasion"]
)
print(prompt.format(toy_type="Miniature Train", occasion="Playtime"))

• Output:

Toy Type: Building Blocks
Occasion: Learning
Ad Copy: Building blocks, perfect for sparking creativity, are the ideal choice for educational play.

Toy Type: Teddy Bear
Occasion: Comfort
Ad Copy: Teddy bears, a cuddly companion, offer comfort and friendship to children.

Toy Type: Lego sports Car
Occasion: Birthday
Ad Copy: Lego sport cars bring thrilling adventures to playtime, perfect for a birthday gift.

Toy Type: Puzzle
Occasion: Brain Teasing
Ad Copy: Puzzles challenge the mind and offer hours of problem-solving fun for all ages.

Toy Type: Miniature Train
Occasion: Playtime

• As evident, the FewShotPromptTemplate is a more intricate type of prompt template that encompasses multiple examples along with a prompt. This kind of template can guide the model to generate corresponding outputs using several examples. Currently, we have created a new prompt that includes specifics for the toy type “Miniature Train” and the occasion “Playtime”.
  • 분명히 FewShotPromptTemplate은 여러 예제와 프롬프트를 포함하는 더 복잡한 종류의 프롬프트 템플릿이다.
  • 이러한 종류의 템플릿은 모델이 여러 예제를 사용하여 해당 출력을 생성하도록 안내할 수 있다.
  • 현재로서는 "Miniature Train" 장난감 유형과 "Playtime" 행사에 관한 구체적인 내용을 포함한 새로움 프롬프트를 생성했다.

Use LLM

• Finally, by passing this object to the large model, we can obtain the desired copy based on the prompt we’ve created!
  • 마지막으로 이 객체를 대형 모델에 전달함으로써 우리가 생성한 프롬프트에 기반한 원하는 광고 복사본을 얻을 수 있게 된다.

from langchain.llms import OpenAI
model = OpenAI(model_name='text-davinci-003')
result = model(prompt.format(toy_type="Miniature Train", occasion="Playtime"))
print(result)

Use Sample Selector

• If we have a large number of examples, it’s impractical and inefficient to send all of them to the model at once. Additionally, including too many tokens in each request can lead to unnecessary data usage (since OpenAI charges based on the number of tokens used).
  • 대량의 예제가 있는 경우 한 번에 모든 예제를 모델에 보내는 것은 비현실적이고 비효율적일 수 있다. 또한 각 요청에 너무 많은 토큰을 포함하는 것은 불필요한 데이터 사용으로 이어질 수 있다.
• LangChain provides an example selector to choose the most appropriate samples. (Note that since the example selector uses vector similarity comparison, a vector database needs to be installed. Here I use Chroma).
  • LangChain은 가장 적절한 샘플을 선택하기 위한 예제 선택기를 제공한다. (예제 선택기는 벡터 유사성 비교를 사용하므로 벡터 데이터베이스가 설치되어 있어야 하며, 여기서는 Chroma를 사용한다.)

from langchain.prompts.example_selector import SemanticSimilarityExampleSelector
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# Initialize the Example Selector
example_selector = SemanticSimilarityExampleSelector.from_examples(
    samples,
    OpenAIEmbeddings(),
    Chroma,
    k=1
)

# Create a FewShotPromptTemplate object using the Example Selector
prompt = FewShotPromptTemplate(
    example_selector=example_selector, 
    example_prompt=prompt_sample, 
    suffix="Toy Type: {toy_type}\nOccasion: {occasion}", 
    input_variables=["toy_type", "occasion"]
)
print(prompt.format(toy_type="Toy Car", occasion="Birthday"))

• In this revised code, the SemanticSimilarityExampleSelector from LangChain is used to select the most relevant examples from the given samples. A FewShotPromptTemplate object is then created using this selector, tailored to the toy context with the provided suffix and input variables. The final prompt is formatted with the toy type “Remote Control Car” and the occasion “Birthday” and then printed.
  • 이 수정된 코드에서는 LangChain의 SemanticSimilarityExampleSelector를 사용하여 주어진 샘플에서 가장 관련성 높은 예제를 선택한다. 그런 다음 이 선택기를 사용하여 새로운 FewShotPromptTemplates 객체를 만들어 제공된 접미사 및 입력 변수로 장난감 컨텍스트에 맞게 맞춘다. 최종 프롬프트는 "Remote Control Car"장난감 유형과 "Birthday"행사로 형식화되어 출력된다.