Sumarização de Texto com LangChain

Diferentes Modelos de Linguagem Grande (Large Language Models - LLM) têm diferentes limitações de comprimento para as palavras de entrada do prompt. Se precisarmos resumir um artigo longo, mas o comprimento do artigo excede o limite máximo do modelo, não podemos alimentar diretamente o artigo inteiro ao modelo de IA. Em tais cenários, o LangChain fornece estratégias e encapsulamento para lidar com isso. Este capítulo apresenta principalmente como o LangChain resolve a sumarização de texto.

Pré-processamento de Dados

Primeiro, preparamos os dados de teste. Neste exemplo, carregamos um documento longo e, em seguida, fatiamos o documento para dividi-lo em vários fragmentos pequenos de documentos.

Observação: O carregamento de dados de arquivos locais aqui é apenas para fins ilustrativos. Em cenários de negócios reais, você pode carregar dados de documentos de seu próprio banco de dados.

from langchain import OpenAI, PromptTemplate, LLMChain
from langchain.text_splitter import CharacterTextSplitter
from langchain.chains.mapreduce import MapReduceChain
from langchain.prompts import PromptTemplate

llm = OpenAI(temperature=0)

text_splitter = CharacterTextSplitter()

with open("../../estado_da_uniao.txt") as f:
    estado_da_uniao = f.read()
textos = text_splitter.split_text(estado_da_uniao)

from langchain.docstore.document import Document

docs = [Document(page_content=t) for t in textos[:3]]

Começando

A maneira mais fácil de resumir um texto longo é usar a tarefa load_summarize_chain fornecida pelo LangChain para executar a tarefa de sumarização de texto.

from langchain.chains.summarize import load_summarize_chain

chain = load_summarize_chain(llm, chain_type="map_reduce")
chain.run(docs)

Usar o Chain encapsulado de sumarização de texto fornecido pelo LangChain é simples. No entanto, se precisar ajustar alguns parâmetros, consulte o conteúdo a seguir. Por exemplo, o exemplo acima usa um modelo de palavras de prompt embutido, que pode não ser amigável para o português. Você pode alterá-lo para o seu próprio modelo de palavras de prompt, entre outras coisas.

Explicação do Parâmetro chain_type

O LangChain projetou 4 métodos de manipulação para o caso em que a palavra de prompt da tarefa de Chain excede o limite de comprimento de token do LLM.

Os 4 tipos de chain_type são os seguintes:

stuff
map_reduce
refine
map_rerank

Tipo stuff

Este é o tipo padrão do LangChain, que envia todo o conteúdo do documento para o modelo LLM para sumarização de uma vez. Portanto, é chamado de modo de "stuffing". Se o conteúdo do documento for muito longo, certamente excederá o limite de token do LLM.

Tipo map_reduce

Este método envia primeiro cada fragmento do documento para o modelo LLM para sumarização individual, em seguida, combina todos os resumos e fornece um resumo geral para a IA, que é semelhante ao conceito das bibliotecas de funções map-reduce em muitas linguagens de programação.

Tipo refine

Este método gera um resumo de texto de forma resumida. Ele envia primeiro o conteúdo do primeiro documento para o modelo LLM para sumarização, depois envia o conteúdo do resumo do primeiro documento + o conteúdo do segundo documento para o modelo LLM para sumarização, e assim por diante, para obter um resumo final para um texto longo.

Tipo map_rerank

Este é usado em tarefas de perguntas e respostas. Ele seleciona fragmentos de documentos com alta relevância para a pergunta e, em seguida, os envia ao modelo LLM para responder à pergunta.

Exemplo da tarefa 'stuff'

Aqui está um exemplo de sumarização de um artigo usando o tipo 'stuff', que é adequado para artigos que não excedem o limite de comprimento do token do LLM:

chain = load_summarize_chain(llm, chain_type="stuff")

chain.run(docs)

Palavras de Prompt Personalizadas

Para o tipo 'stuff', aqui está um exemplo de palavras de prompt personalizadas:

prompt_template = """Sumarize o seguinte conteúdo:

{text}

Resumo:"""
PROMPT = PromptTemplate(template=prompt_template, input_variables=["text"])
chain = load_summarize_chain(llm, chain_type="stuff", prompt=PROMPT)
chain.run(docs)

Exemplo de tarefa `map_reduce`

O map_reduce resume o artigo e, é claro, esse método resultará em várias chamadas do modelo de IA.

chain = load_summarize_chain(llm, chain_type="map_reduce")

chain.run(docs)

Palavras de Ativação Personalizadas para a Tarefa map_reduce

prompt_template = """Resuma o seguinte conteúdo:

{text}

Resumo:"""
PROMPT = PromptTemplate(template=prompt_template, input_variables=["text"])
chain = load_summarize_chain(OpenAI(temperature=0), chain_type="map_reduce", return_intermediate_steps=True, map_prompt=PROMPT, combine_prompt=PROMPT)
chain({"input_documents": docs}, return_only_outputs=True)

Exemplo de tarefa `refine`

Basta alterar o parâmetro chain_type para refine.

chain = load_summarize_chain(llm, chain_type="refine")
chain.run(docs)

Modelo de Palavras Personalizadas para a Tarefa refine

Aqui está um exemplo de palavras personalizadas para a tarefa refine:

prompt_template = """Resuma o seguinte conteúdo:

{text}

Resumo:"""

PROMPT = PromptTemplate(template=prompt_template, input_variables=["text"])

refine_template = (
    "Seu trabalho é gerar um resumo final do texto\n"
    "Aqui estão as informações do resumo existente: {existing_answer}\n"
    "Aprimore o resumo existente com base nas novas informações de contexto\n"
    "As informações de contexto são as seguintes\n"
    "------------\n"
    "{text}\n"
    "------------\n"
    "Com base nas informações de contexto, aprimore o resumo existente\n"
    "Retorne as informações do resumo existente se as informações de contexto não forem úteis."
)
refine_prompt = PromptTemplate(
    input_variables=["existing_answer", "text"],
    template=refine_template,
)
chain = load_summarize_chain(OpenAI(temperature=0), chain_type="refine", return_intermediate_steps=True, question_prompt=PROMPT, refine_prompt=refine_prompt)
chain({"input_documents": docs}, return_only_outputs=True)

Tarefa de Resumo de Texto da LangChain