De Zero a Engenharia de Prompt Avançada com Langchain em Python

Um aspecto importante dos Grandes Modelos de Linguagem (LLMs) é o número de parâmetros que esses modelos usam para aprender. Quanto mais parâmetros um modelo tiver, melhor ele pode compreender a relação entre palavras e frases. Isso significa que modelos com bilhões de parâmetros têm a capacidade de gerar vários formatos de texto criativos e responder a perguntas abertas e desafiadoras de maneira informativa.

LLMs como o ChatGPT, que utilizam o modelo Transformer, são proficientes em entender e gerar linguagem humana, tornando-os úteis para aplicações que requerem compreensão de linguagem natural. No entanto, eles não estão sem limitações, que incluem conhecimento desatualizado, incapacidade de interagir com sistemas externos, falta de compreensão de contexto e, às vezes, gerar respostas plausíveis, mas incorretas ou sem sentido, entre outras.

Para abordar essas limitações, é necessário integrar LLMs com fontes de dados e capacidades externas, o que pode apresentar complexidades e exigir habilidades extensas de codificação e manipulação de dados. Isso, somado aos desafios de entender conceitos de IA e algoritmos complexos, contribui para a curva de aprendizado associada ao desenvolvimento de aplicações que utilizam LLMs.

No entanto, a integração de LLMs com outras ferramentas para formar aplicações impulsionadas por LLMs pode redefinir nosso cenário digital. O potencial dessas aplicações é vasto, incluindo melhorar a eficiência e produtividade, simplificar tarefas, aprimorar a tomada de decisões e fornecer experiências personalizadas.

Neste artigo, vamos mergulhar mais profundamente nesses problemas, explorando as técnicas avançadas de engenharia de prompt com Langchain, oferecendo explicações claras, exemplos práticos e instruções passo a passo sobre como implementá-las.

Langchain, uma biblioteca de ponta, traz conveniência e flexibilidade para projetar, implementar e ajustar prompts. À medida que desempacotamos os princípios e práticas da engenharia de prompt, você aprenderá a utilizar os recursos poderosos do Langchain para aproveitar as forças dos modelos de IA gerativos de ponta, como o GPT-4.

Entendendo Prompts

Antes de mergulhar nas complexidades da engenharia de prompt, é essencial entender o conceito de prompts e sua importância.

Um ‘prompt‘ é uma sequência de tokens usada como entrada para um modelo de linguagem, instruindo-o a gerar um tipo específico de resposta. Prompts desempenham um papel crucial na direção do comportamento de um modelo. Eles podem impactar a qualidade do texto gerado e, quando criados corretamente, podem ajudar o modelo a fornecer resultados perspicazes, precisos e específicos do contexto.

A engenharia de prompt é a arte e ciência de projetar prompts eficazes. O objetivo é obter a saída desejada de um modelo de linguagem. Ao selecionar e estruturar cuidadosamente os prompts, é possível guiar o modelo para gerar respostas mais precisas e relevantes. Na prática, isso envolve ajustar as frases de entrada para atender aos vieses de treinamento e estruturais do modelo.

A sofisticação da engenharia de prompt varia desde técnicas simples, como alimentar o modelo com palavras-chave relevantes, até métodos mais avançados que envolvem o design de prompts complexos e estruturados que usam a mecânica interna do modelo em seu favor.

Langchain: A Ferramenta de Prompt de Crescimento Mais Rápido

LangChain, lançado em outubro de 2022 por Harrison Chase, tornou-se uma das frameworks de código aberto mais bem avaliadas no GitHub em 2023. Ele oferece uma interface simplificada e padronizada para incorporar Grandes Modelos de Linguagem (LLMs) em aplicações. Além disso, fornece uma interface rica em recursos para engenharia de prompt, permitindo que os desenvolvedores experimentem diferentes estratégias e avaliem seus resultados. Ao utilizar o Langchain, você pode realizar tarefas de engenharia de prompt de forma mais eficaz e intuitiva.

LangFlow serve como uma interface de usuário para orquestrar componentes do LangChain em um fluxograma executável, permitindo prototipagem e experimentação rápidas.

LangChain preenche uma lacuna crucial no desenvolvimento de IA para as massas. Ele habilita uma variedade de aplicações de NLP, como assistentes virtuais, geradores de conteúdo, sistemas de resposta a perguntas e muito mais, para resolver uma gama de problemas do mundo real.

Em vez de ser um modelo ou provedor autônomo, o LangChain simplifica a interação com diversos modelos, estendendo as capacidades de aplicações impulsionadas por LLMs além das limitações de uma simples chamada de API.

A Arquitetura do LangChain

Os principais componentes do LangChain incluem Model I/O, Prompt Templates, Memória, Agentes e Cadeias.

Model I/O

O LangChain facilita uma conexão sem esforço com vários modelos de linguagem, envolvendo-os com uma interface padronizada conhecida como Model I/O. Isso facilita uma mudança de modelo sem esforço para otimização ou melhor desempenho. O LangChain suporta vários provedores de modelos de linguagem, incluindo OpenAI, HuggingFace, Azure, Fireworks e mais.

Prompt Templates

Esses são usados para gerenciar e otimizar interações com LLMs, fornecendo instruções concisas ou exemplos. A otimização de prompts melhora o desempenho do modelo, e sua flexibilidade contribui significativamente para o processo de entrada.

Um exemplo simples de um prompt template:

<p>from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="Quais são os avanços recentes no campo de {subject}?")
print(prompt.format(subject="Processamento de Linguagem Natural"))</p>

À medida que avançamos em complexidade, encontramos padrões mais sofisticados no LangChain, como o padrão Reason and Act (ReAct). ReAct é um padrão vital para a execução de ações, onde o agente atribui uma tarefa a uma ferramenta apropriada, personaliza a entrada para ela e analisa sua saída para realizar a tarefa. O exemplo em Python abaixo demonstra um padrão ReAct. Ele mostra como um prompt é estruturado no LangChain, usando uma série de pensamentos e ações para raciocinar sobre um problema e produzir uma resposta final:

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

Memória

A memória é um conceito crítico no LangChain, permitindo que LLMs e ferramentas retenham informações ao longo do tempo. Esse comportamento de estado melhora o desempenho de aplicações do LangChain, armazenando respostas anteriores, interações do usuário, o estado do ambiente e os objetivos do agente. As estratégias de ConversationBufferMemory e ConversationBufferWindowMemory ajudam a manter o controle da conversa completa ou de partes recentes, respectivamente. Para uma abordagem mais sofisticada, a estratégia de ConversationKGMemory permite codificar a conversa como um gráfico de conhecimento que pode ser alimentado de volta em prompts ou usado para prever respostas sem chamar o LLM.

Agentes

Um agente interage com o mundo realizando ações e tarefas. No LangChain, os agentes combinam ferramentas e cadeias para a execução de tarefas. Ele pode estabelecer uma conexão com o mundo exterior para a recuperação de informações para aumentar o conhecimento do LLM, superando assim suas limitações inerentes. Eles podem decidir passar cálculos para um calculadora ou interpretador Python, dependendo da situação.

Os agentes são equipados com subcomponentes:

• Ferramentas: Esses são componentes funcionais.
• Conjuntos de Ferramentas: Coleções de ferramentas.
• Executores de Agentes: Este é o mecanismo de execução que permite escolher entre ferramentas.

Os agentes no LangChain também seguem o padrão Zero-shot ReAct, onde a decisão é baseada apenas na descrição da ferramenta. Esse mecanismo pode ser estendido com memória para considerar a história completa da conversa. Com ReAct, em vez de pedir a um LLM para completar o texto, você pode instruí-lo a responder em um loop de pensamento/ação/observação.

Cadeias

Cadeias, como o termo sugere, são sequências de operações que permitem que a biblioteca LangChain processe entradas e saídas de modelos de linguagem de forma transparente. Esses componentes integrais do LangChain são fundamentalmente compostos por links, que podem ser outras cadeias ou primitivos, como prompts, modelos de linguagem ou utilitários.

Imagine uma cadeia como uma esteira de transporte em uma fábrica. Cada etapa nessa esteira representa uma operação específica, que pode ser invocar um modelo de linguagem, aplicar uma função Python a um texto ou até mesmo instruir o modelo de uma maneira particular.

O LangChain categoriza suas cadeias em três tipos: Cadeias de Utilidade, Cadeias Genéricas e Cadeias de Combinação de Documentos. Vamos mergulhar em Cadeias de Utilidade e Genéricas para nossa discussão.

• Cadeias de Utilidade são projetadas especificamente para extrair respostas precisas de modelos de linguagem para tarefas estreitamente definidas. Por exemplo, vamos dar uma olhada na LLMMathChain. Essa cadeia de utilidade permite que os modelos de linguagem realizem cálculos matemáticos. Ela aceita uma pergunta em linguagem natural, e o modelo de linguagem, por sua vez, gera um trecho de código Python que é então executado para produzir a resposta.
• Cadeias Genéricas, por outro lado, servem como blocos de construção para outras cadeias, mas não podem ser usadas sozinhas. Essas cadeias, como a LLMChain, são fundamentais e são frequentemente combinadas com outras cadeias para realizar tarefas intricadas. Por exemplo, a LLMChain é frequentemente usada para consultar um objeto de modelo de linguagem, formatando a entrada com base em um modelo de prompt fornecido e passando-a para o modelo de linguagem.

Implementação Passo a Passo da Engenharia de Prompt com Langchain

Vamos guiá-lo pelo processo de implementar a engenharia de prompt usando o Langchain. Antes de prosseguir, certifique-se de que você instalou o software e os pacotes necessários.

Você pode aproveitar ferramentas populares como Docker, Conda, Pip e Poetry para configurar o LangChain. Os arquivos de instalação relevantes para cada um desses métodos podem ser encontrados no repositório do LangChain em https://github.com/benman1/generative_ai_with_langchain. Isso inclui um Dockerfile para Docker, um requirements.txt para Pip, um pyproject.toml para Poetry e um arquivo langchain_ai.yml para Conda.

Neste artigo, vamos usar o Pip, o gerenciador de pacotes padrão do Python, para facilitar a instalação e o gerenciamento de bibliotecas de terceiros. Se ele não estiver incluído na sua distribuição do Python, você pode instalar o Pip seguindo as instruções em https://pip.pypa.io/.

Para instalar uma biblioteca com o Pip, use o comando pip install nome_da_biblioteca.

No entanto, o Pip não gerencia ambientes por si só. Para lidar com ambientes diferentes, usamos a ferramenta virtualenv.

Na próxima seção, vamos discutir as integrações de modelo.

Etapa 1: Configurando o Langchain

Primeiro, você precisa instalar o pacote Langchain. Estamos usando o sistema operacional Windows. Execute o seguinte comando no terminal para instalá-lo:

pip install langchain

Etapa 2: Importando o Langchain e outros módulos necessários

Em seguida, importe o Langchain junto com outros módulos necessários. Aqui, também importamos a biblioteca transformers, que é amplamente usada em tarefas de NLP.

<p>import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Etapa 3: Carregar Modelo Pré-Treinado

Open AI

OpenAI modelos podem ser convenientemente interfaceados com a biblioteca LangChain ou a biblioteca de cliente Python da OpenAI. Notavelmente, a OpenAI fornece uma classe de Embedding para modelos de embedding de texto. Dois modelos LLM principais são GPT-3.5 e GPT-4, diferindo principalmente no comprimento do token. Os preços para cada modelo podem ser encontrados no site da OpenAI. Embora haja modelos mais sofisticados como o GPT-4-32K que têm uma aceitação de token mais alta, sua disponibilidade via API não é sempre garantida.

Acessar esses modelos requer uma chave de API da OpenAI. Isso pode ser feito criando uma conta na plataforma da OpenAI, configurando as informações de cobrança e gerando uma nova chave secreta.

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

Depois de criar a chave com sucesso, você pode defini-la como uma variável de ambiente (OPENAI_API_KEY) ou passá-la como um parâmetro durante a instância da classe para chamadas da OpenAI.

Considere um script LangChain para demonstrar a interação com os modelos da OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# O LLM recebe um prompt como entrada e produz uma conclusão
prompt = "quem é o presidente dos Estados Unidos da América?"
conclusao = llm(prompt)

<p>O atual Presidente dos Estados Unidos da América é Joe Biden.</p>

Nesse exemplo, um agente é inicializado para realizar cálculos. O agente recebe uma entrada, uma tarefa de adição simples, processa-a usando o modelo da OpenAI fornecido e retorna o resultado.

Hugging

Hugging Face é uma LIVRE PARA USAR biblioteca de Transformers Python, compatível com PyTorch, TensorFlow e JAX, e inclui implementações de modelos como BERT, T5, etc.

A Hugging Face também oferece o Hugging Face Hub, uma plataforma para hospedar repositórios de código, modelos de aprendizado de máquina, conjuntos de dados e aplicações web.

Para usar a Hugging Face como provedor para seus modelos, você precisará de uma conta e chaves de API, que podem ser obtidas no site deles. O token pode ser disponibilizado no ambiente como HUGGINGFACEHUB_API_TOKEN.

Considere o seguinte trecho de Python que utiliza um modelo de código aberto desenvolvido pelo Google (GOOGL ), o modelo Flan-T5-XXL:

from langchain.llms import HuggingFaceHub

<p>llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64}, repo_id="google/flan-t5-xxl")
prompt = "Em que país fica Tóquio?"
conclusao = llm(prompt)
print(conclusao)</p>

Esse script recebe uma pergunta como entrada e retorna uma resposta, demonstrando o conhecimento e as capacidades de previsão do modelo.

Etapa 4: Engenharia de Prompt Básica

Para começar, vamos gerar um prompt simples e ver como o modelo responde.

prompt = 'Traduza o seguinte texto em inglês para francês: "{0}"'
texto_entrada = 'Olá, como você está?'
ids_entrada = tokenizer.encode(prompt.format(texto_entrada), return_tensors='pt')

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

No trecho de código acima, fornecemos um prompt para traduzir texto em inglês para francês. O modelo de linguagem então tenta traduzir o texto fornecido com base no prompt.

Etapa 5: Engenharia de Prompt Avançada

Embora a abordagem acima funcione bem, ela não aproveita totalmente o poder da engenharia de prompt. Vamos melhorá-la introduzindo estruturas de prompt mais complexas.

prompt = 'Como um tradutor de francês altamente qualificado, traduza o seguinte texto em inglês para francês: "{0}"'
texto_entrada = 'Olá, como você está?'
ids_entrada = tokenizer.encode(prompt.format(texto_entrada), return_tensors='pt')

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

Nesse trecho de código, modificamos o prompt para sugerir que a tradução está sendo feita por um ‘tradutor de francês altamente qualificado’. A mudança no prompt pode levar a traduções melhoradas, pois o modelo agora assume a persona de um especialista.

Construindo um Sistema de Perguntas e Respostas de Literatura Acadêmica com Langchain

Vamos construir um sistema de perguntas e respostas de literatura acadêmica usando o LangChain que possa responder a perguntas sobre artigos acadêmicos recentemente publicados.

Primeiramente, para configurar nosso ambiente, instalamos as dependências necessárias.

pip install langchain arxiv openai transformers faiss-cpu

Após a instalação, criamos um novo notebook Python e importamos as bibliotecas necessárias:

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

O núcleo de nosso sistema de perguntas e respostas é a capacidade de buscar artigos acadêmicos relevantes relacionados a um campo específico, aqui consideramos o Processamento de Linguagem Natural (NLP), usando o banco de dados acadêmico arXiv. Para realizar isso, definimos uma função get_arxiv_data(max_results=10). Essa função coleta as resumos dos artigos de NLP mais recentes do arXiv e os encapsula em objetos de documento do LangChain, usando o resumo como conteúdo e o ID de entrada único como fonte.

Vamos usar a API do arXiv para buscar artigos recentes relacionados ao NLP:

<p>def get_arxiv_data(max_results=10):
search = arxiv.Search(
query="NLP",
max_results=max_results,
sort_by=arxiv.SortCriterion.SubmittedDate,
)</p>

documentos = []

<p>for result in search.results():
documentos.append(Document(
page_content=result.summary,
metadata={"source": result.entry_id},
))</p>

return documentos

Essa função busca os resumos dos artigos de NLP mais recentes do arXiv e os converte em objetos de documento do LangChain. Estamos usando o resumo do artigo e seu ID de entrada único (URL para o artigo) como conteúdo e fonte, respectivamente.

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

Vamos definir nosso corpus e configurar o LangChain:

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

Com nosso sistema de perguntas e respostas acadêmico agora pronto, podemos testá-lo fazendo uma pergunta:

print_answer("Quais são os avanços recentes em NLP?")

A saída será a resposta à sua pergunta, citando as fontes de onde a informação foi extraída. Por exemplo:

<p>Os avanços recentes em NLP incluem modelos de seguimento de instruções reforçados e um novo quadro computacional para resolver problemas de fluxo de potência ótimo alternado (ACOPF) usando unidades de processamento gráfico (GPUs).
FONTES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Você pode facilmente mudar de modelo ou alterar o sistema conforme necessário. Por exemplo, aqui estamos mudando para o GPT-4, que acaba por fornecer uma resposta muito melhor e mais detalhada.

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

<p>Os avanços recentes em Processamento de Linguagem Natural (NLP) incluem o desenvolvimento de modelos de seguimento de instruções reforçados para tarefas de busca de informações, como resposta a perguntas (QA). Esses modelos podem ser adaptados a vários domínios de informações e tarefas sem necessidade de novos treinamentos. No entanto, eles frequentemente lutam para se manter dentro do conhecimento fornecido e podem "alucinar" em suas respostas. Outro avanço é a introdução de um quadro computacional para resolver problemas de fluxo de potência ótimo alternado (ACOPF) usando unidades de processamento gráfico (GPUs). Essa abordagem utiliza uma abstração de dados único para programas não lineares (NLP) e emprega um método de ponto interior (IPM) com uma estratégia de relaxamento de desigualdade. Essa estratégia permite a fatoração da matriz KKT sem pivoteamento numérico, o que anteriormente dificultou a parallelização do algoritmo IPM.
FONTES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Um token no GPT-4 pode ser tão curto quanto um caractere ou tão longo quanto uma palavra. Por exemplo, o GPT-4-32K pode processar até 32.000 tokens em uma única execução, enquanto o GPT-4-8K e o GPT-3.5-turbo suportam 8.000 e 4.000 tokens, respectivamente. No entanto, é importante notar que cada interação com esses modelos vem com um custo que é diretamente proporcional ao número de tokens processados, seja entrada ou saída.

No contexto de nosso sistema de perguntas e respostas, se um artigo acadêmico excede o limite máximo de tokens, o sistema falhará em processá-lo em sua totalidade, afetando assim a qualidade e a completude das respostas. Para contornar esse problema, o texto pode ser dividido em partes menores que atendam ao limite de tokens.

FAISS (Facebook AI Similarity Search) (META ) ajuda a encontrar rapidamente os trechos de texto mais relevantes relacionados à pergunta do usuário. Ele cria uma representação vetorial de cada trecho de texto e usa esses vetores para identificar e recuperar os trechos mais semelhantes à representação vetorial de uma pergunta dada.

É importante lembrar que, mesmo com o uso de ferramentas como o FAISS, a necessidade de dividir o texto em partes menores devido às limitações de tokens pode às vezes levar à perda de contexto, afetando a qualidade das respostas. Portanto, o gerenciamento e a otimização cuidadosos do uso de tokens são cruciais ao trabalhar com esses grandes modelos de linguagem.

pip install faiss-cpu langchain CharacterTextSplitter

Depois de garantir que as bibliotecas acima estejam instaladas, execute

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.faiss import FAISS
from langchain.text_splitter import CharacterTextSplitter
documentos = get_arxiv_data(max_results=10) # Agora podemos usar mais dados
trechos_documentos = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for documento in documentos:
for trecho in splitter.split_text(documento.page_content):
trechos_documentos.append(Document(page_content=trecho, metadata=documento.metadata))

<p>search_index = FAISS.from_documents(trechos_documentos, OpenAIEmbeddings())</p>

<p>chain = load_qa_with_sources_chain(OpenAI(temperature=0))</p>

<p>def print_answer(pergunta):
print(
chain(
{
"input_documents": search_index.similarity_search(pergunta, k=4),
"question": pergunta,
},
return_only_outputs=True,
)["output_text"]
)

Com o código completo, agora temos uma ferramenta poderosa para consultar a literatura acadêmica mais recente no campo de NLP.

Os avanços recentes em NLP incluem o uso de redes neurais profundas (DNNs) para análise automática de texto e tarefas de NLP, como verificação ortográfica, detecção de idioma, extração de entidades, detecção de autor, resposta a perguntas e outras tarefas.
FONTES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Conclusão

A integração de Grandes Modelos de Linguagem (LLMs) em aplicações acelerou a adoção em vários domínios, incluindo tradução de linguagem, análise de sentimento e recuperação de informações. A engenharia de prompt é uma ferramenta poderosa para maximizar o potencial desses modelos, e o Langchain está liderando o caminho na simplificação dessa tarefa complexa. Sua interface padronizada, modelos de prompt flexíveis, integração de modelo robusta e o uso inovador de agentes e cadeias garantem resultados ótimos para o desempenho dos LLMs.

No entanto, apesar desses avanços, há algumas dicas a serem lembradas. Ao usar o Langchain, é essencial entender que a qualidade da saída depende fortemente da formulação do prompt. Experimentar diferentes estilos e estruturas de prompt pode render resultados aprimorados. Além disso, lembre-se de que, embora o Langchain suporte uma variedade de modelos de linguagem, cada um tem suas forças e fraquezas. Escolher o modelo certo para sua tarefa específica é crucial. Por fim, é importante lembrar que o uso desses modelos vem com considerações de custo, pois o processamento de tokens afeta diretamente o custo das interações.

Como demonstrado no guia passo a passo, o Langchain pode impulsionar aplicações robustas, como o sistema de perguntas e respostas de literatura acadêmica. Com uma comunidade de usuários em crescimento e uma presença cada vez mais proeminente no cenário de código aberto, o Langchain promete ser uma ferramenta fundamental para aproveitar todo o potencial dos LLMs, como o GPT-4.

interações. Como demonstrado no guia passo a passo, o Langchain pode impulsionar aplicações robustas, como o sistema de perguntas e respostas de literatura acadêmica. Com uma comunidade de usuários em crescimento e uma presença cada vez mais proeminente no cenário de código aberto, o Langchain promete ser uma ferramenta fundamental para aproveitar todo o potencial dos LLMs, como o GPT-4.