Riassunto automatico del testo con LangChain

I diversi Large Language Models (LLM) hanno limiti di lunghezza diversi per le parole di input. Se dobbiamo riassumere un lungo articolo, ma la lunghezza dell'articolo supera il limite massimo del modello, non possiamo alimentare direttamente l'intero articolo al modello AI. In questi scenari, LangChain fornisce strategie ed encapsulation per gestire questo problema. Questo capitolo introduce principalmente come LangChain risolve il riassunto del testo.

Preelaborazione dei dati

Innanzitutto, prepariamo i dati di test. In questo esempio, carichiamo un lungo documento e poi suddividiamo il documento in più frammenti di documenti piccoli.

Nota: Il caricamento dei dati del file locale qui è solo a scopo illustrativo. In scenari di business reali, potresti caricare i dati del documento dal tuo database.

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("../../state_of_the_union.txt") as f:
    state_of_the_union = f.read()
texts = text_splitter.split_text(state_of_the_union)

from langchain.docstore.document import Document

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

Inizio

Il modo più semplice per riassumere un lungo testo è utilizzare il task load_summarize_chain fornito da LangChain per eseguire il compito di riassunto del testo.

from langchain.chains.summarize import load_summarize_chain

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

Utilizzare la catena di riassunto del testo incapsulata fornita da LangChain è semplice. Tuttavia, se è necessario regolare alcuni parametri, fare riferimento ai contenuti seguenti. Ad esempio, l'esempio sopra utilizza un modello di parole d'input incorporato, che potrebbe non essere adatto per il cinese. Puoi cambiarlo con il tuo modello di parole d'input e così via.

Spiegazione del parametro chain_type

LangChain ha progettato 4 metodi di gestione nel caso in cui la parola d'input del compito della catena superi il limite di lunghezza del token di LLM.

I 4 tipi di chain_type sono i seguenti:

stuff
map_reduce
refine
map_rerank

Tipo stuff

Questo è il tipo predefinito di LangChain, che invia l'intero contenuto del documento al modello LLM per riassumerlo in una volta sola. Perciò è chiamato modalità di stuffing. Se il contenuto del documento è troppo lungo, supererà sicuramente il limite del token di LLM.

Tipo map_reduce

Questo metodo invia prima ciascun frammento del documento al modello LLM per il rispettivo riassunto, quindi combina tutti i riassunti e fornisce infine un riassunto generale all'AI, che è simile al concetto delle librerie di funzioni map-reduce in molti linguaggi di programmazione.

Tipo refine

Questo metodo genera un riassunto del testo in modo riassumente. Invia prima il contenuto del primo documento al modello llm per riassumerlo, quindi invia il contenuto del riassunto del primo documento + il contenuto del secondo documento al modello llm per riassumerlo, e così via, per ottenere un riassunto finale per un lungo testo.

Tipo map_rerank

Questo viene utilizzato nei compiti di domande e risposte. Seleziona i frammenti di documento con un'elevata rilevanza alla domanda e poi li invia al modello llm per rispondere alla domanda.

Esempio del compito `stuff`

Ecco un esempio di riassunto di un articolo utilizzando il tipo stuff, adatto per articoli che non superano il limite di lunghezza del token di LLM:

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

chain.run(docs)

Parole d'input personalizzate

Per il tipo stuff, ecco un esempio di parole d'input personalizzate:

prompt_template = """Riassumi il seguente contenuto:

{text}

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

Esempio di attività `map_reduce`

Il metodo map_reduce riassume l'articolo e, naturalmente, questo metodo comporterà chiamate multiple ai modelli AI.

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

chain.run(docs)

Parole Prompt personalizzate per l'attività map_reduce

prompt_template = """Riassumi il seguente contenuto:

{text}

Sommario:"""
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)

Esempio di attività `refine`

Basta cambiare il parametro chain_type in refine.

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

Template di parole Prompt personalizzate per l'attività Refine

Ecco un esempio di parole prompt personalizzate per l'attività refine:

prompt_template = """Riassumi il seguente contenuto:

{text}

Sommario:"""

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

refine_template = (
    "Il tuo compito è generare un riassunto di testo finale\n"
    "Ecco le informazioni di riassunto esistenti: {existing_answer}\n"
    "Migliora il riassunto esistente in base alle nuove informazioni di background\n"
    "Le informazioni di background sono le seguenti\n"
    "------------\n"
    "{text}\n"
    "------------\n"
    "In base alle informazioni di background, migliora il riassunto esistente\n"
    "Restituisci le informazioni di riassunto esistenti se le informazioni di background non sono utili."
)
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)

Attività di Riassunto del Testo LangChain