Output Parsers no LangChain: Uma breve introdução

Sejam bem-vindos ao nosso terceiro artigo da série sobre LangChain. Hoje, iremos falar sobre output parsers ou analisadores de saída. Então, vamos lá!

Fonte: DALL·E

Os analisadores de saída no LangChain são ferramentas essenciais para transformar as saídas de texto não estruturadas de grandes modelos de linguagem (LLMs) em formatos estruturados que podem ser facilmente utilizados em aplicativos. Imagine-os como os “tradutores” que transformam o discurso do LLM em algo que podemos entender e aplicar em nossos aplicativos e sistemas.

Este artigo explorará três tipos específicos de analisadores de saída: Comma Separated List Output Parser, Pydantic Parser e Structured Output Parser. Cada analisador atende a um propósito único e pode ajudar a otimizar o processamento de saídas do LLM.

O que são Output Parsers?

Os analisadores de saída são classes do LangChain que ajudam a estruturar as respostas de texto de LLMs em um formato predeterminado, permitindo utilizar essas informações, agora de forma estruturada, para as mais diversas finalidades que nossas aplicações possam demandar. Eles podem converter texto bruto em JSON, classes de dados Python ou outros formatos estruturados. As principais funções dos analisadores de saída incluem:

1. Converter texto não estruturado em dados estruturados: Isso pode envolver a análise de texto em formatos como JSON ou objetos Python.
2. Injetar instruções em prompts: Os analisadores podem fornecer instruções de formatação para orientar os LLMs sobre como estruturar suas respostas.

Antes de começar as definições e exemplos, vocês podem conferir os códigos desenvolvidos com mais detalhes neste artigo, clicando aqui.

1. Comma Separated List OutputParser

O Comma Separated List OutputParser é uma abordagem simples que permite extrair listas de itens a partir das respostas de um LLM. Ele é útil quando você deseja que o modelo gere uma lista de elementos, como itens de uma lista de compras, tópicos de discussão ou qualquer outra coleção de dados.

Exemplo de Uso

Suponha que você queira recuperar uma lista de esportes que não utilizam bola. Você poderia usar o seguinte código:

1. Importações Necessárias

from langchain import PromptTemplate
from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain.llms import OpenAI

# Instância da OpenAI
llm = OpenAI(
    api_key= userdata.get('OPENAI-KEY')
)

• PromptTemplate: Classe que permite criar templates de prompts que podem ser preenchidos com variáveis dinâmicas.
• CommaSeparatedListOutputParser: Parser que converte saídas de texto em listas separadas por vírgulas.
• OpenAI: Classe que representa o modelo de linguagem da OpenAI, permitindo interagir com ele.
• Instância do LLM: Um objeto OpenAI é criado, utilizando uma chave de API obtida de um objeto userdatadisponibilizado pelo Google Colab. Isso permite que você faça chamadas ao modelo de linguagem da OpenAI.

2. Instanciação do Parser e Obtenção das Instruções de Formatação

# Instanciação do CommaSeparatedListOutputParse
parser = CommaSeparatedListOutputParser()
format_instructions = parser.get_format_instructions()

• Instância do Parser: Um objeto CommaSeparatedListOutputParser é criado para lidar com a formatação da saída.
• Instruções de Formatação: O método get_format_instructions() é chamado para obter as instruções que o modelo deve seguir ao formatar sua resposta. Essas instruções geralmente indicam que a saída deve ser uma lista de valores separados por vírgulas.

3. Criação do PromptTemplate

# Criação do PromptTemplate
prompt = PromptTemplate(
    template="""Fale 3 {things}.\n{format_instructions}""",
    input_variables=["things"],
    partial_variables={"format_instructions": format_instructions}
)

• Template do Prompt: Um objeto PromptTemplate é criado com um template que solicita ao modelo que "Fale 3 {things}", onde {things} será substituído por uma variável que define o que o modelo deve listar.
• Variáveis de Entrada: A lista input_variables contém a variável things, que será preenchida dinamicamente.
• Variáveis Parciais: A variável format_instructions é passada como uma variável parcial, o que significa que seu valor já foi definido anteriormente e será incluído automaticamente no prompt final.

4. Definição do Contexto e Formatação do Prompt

# Definição do Contexto
things = "esportes que não usam bolas"
description = prompt.format(things=things)

• Definição do Contexto: A variável things é definida como "esportes que não usam bolas".
• Formatação do Prompt: O método format do PromptTemplate é chamado para gerar o prompt final, substituindo {things} pela string "esportes que não usam bolas" e {format_instructions} pelas instruções de formatação obtidas anteriormente.

5. Geração da Resposta do LLM

# Geração da Resposta do LLM
output = llm(description)
print(output)

# Output: natação, ginástica, corrida

• Chamada ao Modelo de Linguagem: A variável description, que contém o prompt formatado, é passada para o modelo de linguagem (representado aqui como llm). O modelo gera uma resposta com base no prompt.
• Impressão da Saída: A resposta do modelo é impressa no console. Essa resposta deve conter uma lista de três esportes que não usam bolas, formatada de acordo com as instruções de formatação.

2. Pydantic Parser

O Pydantic Parser aproveita os modelos Pydantic para validar e analisar a saída. Este analisador é ideal para cenários em que você precisa de validação rigorosa da estrutura de saída, garantindo que os dados estejam em conformidade com os tipos esperados.

Exemplo de Uso

Nesse exemplo, criamos uma classe chamada Carro que carrega algumas informações, como nome, modelo do carro, características e a fonte da pesquisa:

1. Importação de Módulos

from pydantic import BaseModel, Field
from typing import List
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts.chat import HumanMessagePromptTemplate, ChatPromptTemplate
from langchain.chat_models import ChatOpenAI

# Para controlar a aleatoriedade e a criatividade do texto gerado de um LLM, use temperatura = 0,0
chat = ChatOpenAI(temperature=0.0, api_key=userdata.get('OPENAI-KEY'))

• Pydantic: Importa BaseModel e Field, que são usados para criar modelos de dados com validação.
• List: Importa o tipo List do módulo typing, que é usado para definir listas de tipos específicos.
• PydanticOutputParser: Importa a classe PydanticOutputParser da biblioteca LangChain.
• Templates: Importa classes para criar templates de mensagens de chat.
• ChatOpenAI: Importa a classe que permite interagir com os modelos de chat da OpenAI.

2. Definição do Modelo Pydantic

class Car(BaseModel):
    name: str = Field(description="Nome do carro")
    model_number: str = Field(description="Número do modelo do carro")
    features: List[str] = Field(description="Lista de características do carro")
    source: str = Field(description='Fonte da resposta. Deve conter apenas o site')

• Modelo Car: Define um modelo de dados chamado Car que herda de BaseModel.
• Campos:
• name: Nome do carro, do tipo str.
• model_number: Número do modelo do carro, do tipo str.
• features: Lista de características do carro, do tipo List[str].
• source: Fonte da resposta, do tipo str, que deve conter apenas o site de onde a informação foi obtida.
• Field: Cada campo é anotado com Field, que permite adicionar descrições e outras informações úteis para validação.

3. Criação do Output Parser

# output parser
output_parser = PydanticOutputParser(pydantic_object=Car)
print(output_parser.get_format_instructions())

• Instância do Parser: Cria uma instância do PydanticOutputParser, passando o modelo Car como argumento. Isso permite que o parser valide e estruture as respostas de acordo com o modelo definido.
• Instruções de Formato: O método get_format_instructions() é chamado para obter instruções sobre o formato esperado da saída. Essas instruções ajudam a guiar o modelo na geração de uma resposta que se encaixe no formato esperado.

4. Criação do Prompt para o Modelo

# Criação do prompt
human_template = "{human_message}\n{format_instructions}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([human_message_prompt])
prompt = chat_prompt.format_prompt(human_message='Me fale sobre o carro mais caro do mundo',
                                   format_instructions=output_parser.get_format_instructions())

• Template de Mensagem: Define um template human_template que inclui a mensagem do usuário e as instruções de formato.
• Criação do Prompt:
• HumanMessagePromptTemplate.from_template(human_template): Cria um template de mensagem humana a partir do template definido.
• ChatPromptTemplate.from_messages([human_message_prompt]): Cria um template de chat que contém a mensagem humana.
• chat_prompt.format_prompt(...): Formata o prompt, substituindo {human_message} pela pergunta sobre o carro mais caro do mundo e {format_instructions} pelas instruções de formato obtidas anteriormente.

5. Chamada ao Modelo e Processamento da Resposta

response = chat(messages=prompt.to_messages())
print(response.content)
print('\n')

output = output_parser.parse(response.content)
print(output)

# Output:
{
  "name": "Bugatti La Voiture Noire",
  "model_number": "Not specified",
  "features": [
    "Engine: 8.0L quad-turbocharged W16",
    "Horsepower: 1,479",
    "Top Speed: 261 mph",
    "0-60 mph: 2.5 seconds",
    "Price: $18.68 million"
  ],
  "source": "https://www.bugatti.com/"
}

• Chamada ao Modelo: A função chat(messages=prompt.to_messages()) é chamada para enviar o prompt ao modelo de linguagem. O resultado é armazenado na variável response.
• Impressão da Resposta: O conteúdo da resposta é impresso.
• Parsing da Resposta: O método parse do output_parser é chamado com o conteúdo da resposta. Isso valida e estrutura a resposta de acordo com o modelo Car. O resultado é armazenado na variável output.
• Impressão do Output: O resultado final, que agora deve ser um objeto do modelo Car, é impresso.

Este código ilustra como usar o Pydantic Parser para validar e estruturar dados obtidos de um modelo de linguagem. A abordagem permite que você defina claramente a estrutura esperada dos dados, facilitando a manipulação e o uso dessas informações em sua aplicação.

Structured Output Parser

O Structured Output Parser é uma abordagem mais avançada que permite extrair informações estruturadas a partir de respostas de LLM. Ele é útil quando você precisa de dados em um formato específico, como dicionários ou objetos, onde cada elemento tem um nome e um valor.

Exemplo de Uso

Neste exemplo, vamos questionar sobre “Qual a capital da Espanha” e o nosso modelo deve retornar com a resposta e um fato interessante sobre Madrid:

1. Importação de Módulos

from langchain.output_parsers import StructuredOutputParser, ResponseSchema

• StructuredOutputParser: Importa a classe que permite estruturar e validar as saídas de um modelo de linguagem com base em esquemas de resposta definidos.
• ResponseSchema: Importa a classe que define a estrutura de uma resposta esperada, permitindo que você especifique o nome e a descrição de cada parte da resposta.

2. Definição dos Esquemas de Resposta

# Esta definindo uma lista de esquemas de resposta. Cada esquema de resposta é criado usando a classe ResponseSchema e define um tipo de resposta que o modelo de linguagem pode gerar.
response_schemas = [
    ResponseSchema(name="answer", description="resposta à pergunta do usuário"),
    ResponseSchema(name="fact", description="comente sobre um fato interessante da resposta")
]

• response_schemas: Cria uma lista de esquemas de resposta. Cada esquema é uma instância da classe ResponseSchema, que define o que o modelo deve retornar.
• name="answer": Define um esquema que representa a resposta principal à pergunta do usuário.
• name="fact": Define um esquema que permite que o modelo forneça um fato interessante relacionado à resposta.

3. Criação do Structured Output Parser e Instruções de Formato

# Esta criando uma instância da classe StructuredOutputParser usando os esquemas de resposta definidos anteriormente.
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)

# Chamando o método get_format_instructions do output_parser para obter instruções sobre como formatar a saída do modelo de linguagem.
format_instructions = output_parser.get_format_instructions()

• Instância do Parser: Cria uma instância do StructuredOutputParser usando os esquemas de resposta definidos anteriormente. Isso permite que o parser entenda como processar a saída do modelo de linguagem de acordo com os esquemas especificados.
• Instruções de Formato: Chama o método get_format_instructions() do output_parser para obter instruções sobre como o modelo deve formatar a saída. Essas instruções são importantes para guiar o modelo na geração de respostas que se encaixem nos esquemas definidos.

4. Criação do Prompt

# Criação do prompt
prompt = PromptTemplate(
    template="Responda a seguinte questão:\n{question}\n{format_instructions}",
    input_variables=["question"],
    partial_variables={"format_instructions": format_instructions}
)

• PromptTemplate: Cria um template de prompt que será usado para interagir com o modelo de linguagem.
• template: Define o texto do prompt, que inclui a pergunta do usuário e as instruções de formatação.
• input_variables: Especifica que a variável question será fornecida ao prompt.
• partial_variables: Define que as format_instructions obtidas anteriormente serão incluídas no prompt.

5. Formatação da Questão e Resposta do Modelo

# Passando a questão para o prompt
_input = prompt.format_prompt(question="Qual é a capital da Espanha?")

# Resposta do LLM e impressão
output = llm(_input.text)
output_parser.parse(output)

# Output
{'answer': 'Madri',
 'fact': 'A capital da Espanha é a terceira maior cidade da União Europeia, com uma população de mais de 3 milhões de habitantes.'}

• Formatando o Prompt: O método format_prompt() é chamado para substituir {question} e {format_instructions} no template, gerando o prompt final que será enviado ao modelo.
• Chamada ao Modelo: A função get_completion(_input.text) é chamada para enviar o prompt ao modelo de linguagem e obter a resposta. (Nota: get_completion deve ser uma função definida em outro lugar que interage com o modelo de linguagem).
• Parsing da Resposta: O método parse() do output_parser é chamado com a resposta do modelo. Isso valida e estrutura a resposta de acordo com os esquemas definidos anteriormente.

Conclusão

Neste artigo, exploramos as diversas abordagens de Output Parsers disponíveis na biblioteca LangChain, focando em três tipos principais: Comma Separated List OutputParser, Structured Output Parser e Pydantic Parser. Cada uma dessas abordagens oferece uma maneira única de interpretar e estruturar as respostas geradas por LLMs, permitindo que desenvolvedores e pesquisadores integrem essas tecnologias de forma mais eficaz em suas aplicações.

Ao escolher a abordagem de Output Parser adequada, é fundamental considerar a natureza dos dados que você deseja extrair e como esses dados serão utilizados em sua aplicação. Cada método tem suas próprias vantagens e pode ser adaptado a diferentes cenários. Compreender essas ferramentas não apenas melhora a eficiência do seu trabalho, mas também abre novas possibilidades para a criação de aplicações mais inteligentes e responsivas.

Esperamos que este artigo tenha fornecido uma visão clara e prática sobre como utilizar Output Parsers na LangChain. À medida que você avança em seus projetos, considere como essas abordagens podem ser aplicadas para maximizar a eficácia das interações com LLM.

Vamos ao próximo desafio: Linguagem de Expressão LangChain (LCEL)!

Desenvolvido por: Gabriel Lino Garcia.