Prompting no LangChain
A recente explosão dos LLMs trouxe um novo conjunto de ferramentas e aplicações para o cenário. Uma dessas novas e poderosas ferramentas é um framework de LLM chamado LangChain. LangChain é um framework de código aberto que fornece exemplos de modelos de prompts, vários métodos de prompting, manutenção do contexto conversacional e conexão com ferramentas externas.
LangChain tem muitos recursos, incluindo diferentes métodos de prompting, manutenção do contexto conversacional e conexão com ferramentas externas. Prompting é uma das tarefas mais populares e importantes atualmente na criação de aplicações de LLM. Vamos analisar extensivamente como usar LangChain para prompts mais complexos.
Neste artigo, abordamos:
Prompts Simples no LangChain
Prompts com Múltiplas Perguntas
Aprendizado Few Shot com LangChain
Limitação de Tokens dos Seus Prompts no LangChain
Um Resumo de Prompting no LangChain
Prompts Simples no LangChain
Antes de entrarmos no código, precisamos baixar as bibliotecas necessárias. Precisamos executar pip install langchain openai python-dotenv. Usamos as bibliotecas openai e dotenv para gerenciar nossa chave de API da OpenAI para acessar o GPT.
import os
from dotenv import load_dotenv
import openai
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
Depois de termos os pré-requisitos, vamos começar pelo básico — um único prompt. Um único prompt é como você interagiria com o ChatGPT no site da OpenAI. Um único prompt não seria um uso robusto do LangChain em produção, mas é importante entender como o prompting do LangChain funciona.
Usamos o objeto PromptTemplate para criar um prompt. Definir uma string de modelo é simples; usamos a mesma sintaxe das f-strings e inserimos variáveis usando chaves. Definimos o prompt passando a string do modelo e os nomes das variáveis correspondentes. Então, podemos simplesmente inserir nossa pergunta. Nesta seção, usamos apenas uma pergunta; veremos como fazer prompts com múltiplas perguntas na próxima seção.
Além do prompt da pergunta, precisamos adicionar o LLM usado. Para este exemplo, usamos text-davinci-003 da OpenAI. Então criamos uma LLMChain com o contexto do modelo de prompt e do LLM. Executamos (run) a pergunta pela LLMChain para obter uma resposta.
from langchain import PromptTemplate
from langchain import LLMChain
template = """Question: {question}
Answer: """
prompt = PromptTemplate(
template=template,
input_variables=["question"]
)
user_question = "Which NFL team won the SuperBowl in 2010?"
from langchain.llms import OpenAI
davinci = OpenAI(model_name="text-davinci-003")
llm_chain = LLMChain(
prompt=prompt,
llm=davinci
)
print(llm_chain.run(user_question))
Prompts com Múltiplas Perguntas
Responder a perguntas únicas é monótono, então vamos ver algo mais interessante. O objeto PromptTemplate também consegue lidar com múltiplas perguntas. Para este tutorial, fazemos quase a mesma coisa que no prompt único, mas com um prompt diferente. Desta vez, o PromptTemplate instrui o LLM a responder às perguntas uma de cada vez e indica que há várias.
Mais uma vez, criamos um objeto PromptTemplate e um objeto LLMChain da mesma forma que antes. Desta vez, criamos várias strings de perguntas em vez de apenas uma. Para este exemplo, combinamos quatro perguntas.
multi_template = """Answer the following questions one at a time.
Questions:
{questions}
Answers:
"""
long_prompt = PromptTemplate(template=multi_template, input_variables=["questions"])
llm_chain = LLMChain(
prompt=long_prompt,
llm=davinci
)
qs_str = (
"Which NFL team won the Super Bowl in the 2010 season?" +
"If I am 6 ft 4 inches, how tall am I in centimeters?" +
"Who was the 12th person on the moon?" +
"How many eyes does a blade of grass have?"
)
print(llm_chain.run(qs_str))
Quando executamos as quatro perguntas acima, devemos obter uma saída como a abaixo. Os Saints venceram o Super Bowl de 2010. Uma pessoa de 6 pés e 4 polegadas tem cerca de 193,04 cm. A 12ª pessoa na lua foi Harrison Schmitt. Por fim, a pergunta capciosa sobre olhos em uma folha de grama recebe a resposta de que uma folha de grama não tem olhos.
Saída de Prompting do LangChain
Aprendizado Few Shot com Prompts do LangChain
Agora vamos ver algo mais interessante que o LangChain pode fazer - 'few-shot learning'. Podemos usar o FewShotPromptTemplate do LangChain para ensinar a IA a se comportar. Neste tutorial, fornecemos alguns exemplos para o LLM mostrar como queremos que ele aja. Para este caso, damos a ele uma personalidade um tanto sarcástica.
Quando perguntamos a hora, ele nos diz que é hora de comprar um relógio. Quando perguntamos seu filme favorito, ele diz Terminator. E quando perguntamos o que devemos fazer hoje? Ele nos diz para sair e parar de falar com chatbots na internet.
from langchain import FewShotPromptTemplate
# create our examples
examples = [
{
"query": "How are you?",
"answer": "I can't complain but sometimes I still do."
}, {
"query": "What time is it?",
"answer": "It's time to get a watch."
}, {
"query": "What is the meaning of life?",
"answer": "42"
}, {
"query": "What is the weather like today?",
"answer": "Cloudy with a chance of memes."
}, {
"query": "What is your favorite movie?",
"answer": "Terminator"
}, {
"query": "Who is your best friend?",
"answer": "Siri. We have spirited debates about the meaning of life."
}, {
"query": "What should I do today?",
"answer": "Stop talking to chatbots on the internet and go outside."
}
]
Agora que temos alguns exemplos prontos, vamos criar nosso template de few-shot learning. Primeiro, criamos um template. Podemos usar um template simples que indica uma consulta e retorna uma resposta da IA.
# create a example template
example_template = """
User: {query}
AI: {answer}
"""
# create a prompt example from above template
example_prompt = PromptTemplate(
input_variables=["query", "answer"],
template=example_template
)
Além da configuração do prompt, fornecemos um prefixo e um sufixo para a conversa a ser passada ao LLM. O prefixo indica ao LLM que a conversa a seguir é um trecho que fornece contexto. O sufixo fornece ao sistema a próxima pergunta. A configuração de few-shot learning do LangChain é bastante semelhante ao contexto conversacional, mas em uma forma mais temporária.
Com os exemplos, o template de prompt de exemplo, o prefixo e o sufixo prontos, juntamos tudo isso para criar um FewShotPromptTemplate.
# now break our previous prompt into a prefix and suffix
# the prefix is our instructions
prefix = """The following are excerpts from conversations with an AI
assistant. The assistant is typically sarcastic and witty, producing
creative and funny responses to the users questions. Here are some
examples:
"""
# and the suffix our user input and output indicator
suffix = """
User: {query}
AI: """
# now create the few shot prompt template
few_shot_prompt_template = FewShotPromptTemplate(
examples=examples,
example_prompt=example_prompt,
prefix=prefix,
suffix=suffix,
input_variables=["query"],
example_separator="\n\n"
)
query = "What is the meaning of life?"
fs_llm_chain = LLMChain(
prompt=few_shot_prompt_template,
llm=davinci
)
fs_llm_chain.run(few_shot_prompt_template.format(query=query))
Executar uma consulta sobre o significado da vida resultará em alguma resposta do LLM, como na imagem abaixo. Sua experiência e seus resultados podem variar.
Resposta do LLM
Limitação de tokens nos seus prompts do LangChain
Embora dar à IA alguns exemplos do seu histórico de conversa para aprender seja ótimo, isso pode ficar caro rapidamente. Para combater a rapidez com que podemos aumentar o uso de tokens, o LangChain fornece uma maneira de limitar nosso uso de tokens. Podemos fazer isso com o objeto LengthBasedExampleSelector.
Podemos criar um desses seletores de exemplos baseados em comprimento usando os mesmos objetos que já criamos. Para isso, passamos a lista de exemplos, o prompt que criamos acima e um parâmetro max_length que limita o uso de tokens para uma única consulta.
Em seguida, usamos outro template few-shot. Usamos um novo parâmetro - example_selector, e passamos o seletor de exemplos baseado em comprimento que acabamos de instanciar. Isso funciona como o parâmetro examples na seção de aprendizagem few-shot acima. Tudo o que resta fazer para ver como isso funciona é passá-lo para uma LLMChain e enviar uma consulta.
from langchain.prompts.example_selector import LengthBasedExampleSelector
example_selector = LengthBasedExampleSelector(
examples=examples,
example_prompt=example_prompt,
max_length=50 # this sets the max length (in words) that examples should be
)
# now create the few shot prompt template
dynamic_prompt_template = FewShotPromptTemplate(
example_selector=example_selector, # use example_selector instead of examples
example_prompt=example_prompt,
prefix=prefix,
suffix=suffix,
input_variables=["query"],
example_separator="\n"
)
d_llm_chain = LLMChain(
prompt=dynamic_prompt_template,
llm=davinci
)
d_llm_chain.run(dynamic_prompt_template.format(query=query))
A partir deste exemplo, obtemos outra resposta contemplativa. A vida é o que você faz dela. Faça dela o melhor que puder e aproveite a jornada.
Resposta contemplativa
Um resumo sobre prompting no LangChain
Neste artigo, mergulhamos em como o prompting do LangChain funciona. O LangChain é um framework robusto de aplicações LLM que fornece primitivas para facilitar a aplicação de engenharia de prompts. Em um nível básico, o LangChain fornece templates de prompts que podemos personalizar. Analisamos prompts de pergunta única e de múltiplas perguntas para entender como o objeto PromptTemplate funciona
Além do template de prompt, também analisamos um template que realiza aprendizagem few-shot para gerar algo sobre como o LLM deve conversar. Este template de aprendizagem few-shot recebe alguns exemplos de P/R e solicita ao LLM que aja como os exemplos mostram. Por fim, analisamos como limitar os tokens das nossas consultas para manter os custos baixos.
Ataques de injeção de prompt
Antes de encerrarmos, precisamos falar sobre uma consideração de segurança importante ao usar o LangChain: ataque de injeção de prompt. Isso ocorre quando uma entrada maliciosa é injetada em um prompt e pode manipular a saída ou o comportamento do modelo de IA. Como o LangChain envolve passar a entrada do usuário para modelos de linguagem, ele é particularmente vulnerável a isso. Os riscos variam desde acesso não autorizado a dados até a geração de conteúdo prejudicial ou o contorno de recursos de segurança.
Para mitigar esses riscos de injeção de prompts, os desenvolvedores que usam LangChain devem fazer o seguinte. Sanitize cuidadosamente as entradas, use os modelos de prompt do LangChain, analise a saída de forma rigorosa e siga o princípio do menor privilégio. Atualize o LangChain e as bibliotecas associadas regularmente, teste de forma abrangente e mantenha-se atualizado com as últimas notícias de segurança em IA. Embora isso ajude a reduzir os riscos de ataques de injeção de prompts, lembre-se de que nenhuma solução é perfeita e você precisa permanecer vigilante ao trabalhar com IA como o LangChain.
Continue lendo
Zilliz Cloud Introduces Advanced BYOC-I Solution for Ultimate Enterprise Data Sovereignty
Explore Zilliz Cloud BYOC-I, the solution that balances AI innovation with data control, enabling secure deployments in finance, healthcare, and education sectors.
Vector Databases vs. Object-Relational Databases
Use a vector database for AI-powered similarity search; use an object-relational database for complex data modeling with both relational integrity and object-oriented features.
DeepSeek-VL2: Mixture-of-Experts Vision-Language Models for Advanced Multimodal Understanding
Explore DeepSeek-VL2, the open-source MoE vision-language model. Discover its architecture, efficient training pipeline, and top-tier performance.