Résumé automatique de texte

Les différents modèles de langage de grande taille (LLM) ont des limitations de longueur différentes pour les mots d'entrée dans l'invite. Lorsqu'il est nécessaire de résumer un long article, mais que sa longueur dépasse la limite maximale du modèle, il n'est pas possible de fournir directement l'article complet au modèle d'IA. Dans de tels scénarios, LangChain propose des stratégies et une encapsulation pour gérer cela. Ce chapitre présente principalement comment LangChain résout la problématique de résumé de texte.

Prétraitement des données

Tout d'abord, nous préparons les données de test. Dans cet exemple, nous chargeons un long document, puis découpons le document en plusieurs petits fragments de document.

Note : le chargement des données de fichier local ici est uniquement à des fins d'illustration. Dans des scénarios professionnels réels, vous pourriez charger les données du document à partir de votre propre base de données.

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]]

Pour commencer

La manière la plus simple de résumer un long texte est d'utiliser la tâche load_summarize_chain fournie par LangChain pour exécuter la tâche de résumé de texte.

from langchain.chains.summarize import load_summarize_chain

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

L'utilisation de la chaîne encapsulée de résumé de texte fournie par LangChain est simple. Cependant, si vous devez affiner certains paramètres, veuillez vous référer au contenu suivant. Par exemple, l'exemple ci-dessus utilise un modèle de mots d'invite intégré, qui peut ne pas être convivial pour le chinois. Vous pouvez le changer pour votre propre modèle de mots d'invite, etc.

Explication du paramètre chain_type

LangChain a conçu 4 méthodes de traitement pour les cas où le mot d'invite de la tâche Chain dépasse la limite de longueur de jeton du LLM.

Les 4 types de chain_type sont les suivants :

stuff
map_reduce
refine
map_rerank

Type stuff

Il s'agit du type par défaut de LangChain, qui envoie tout le contenu du document au modèle LLM pour en faire un résumé. Il est donc appelé mode stuffing. Si le contenu du document est trop long, il dépassera certainement la limite de jetons du LLM.

Type map_reduce

Cette méthode envoie d'abord chaque fragment de document au modèle LLM pour un résumé individuel, puis combine tous les résumés, et fournit enfin un résumé global à l'IA, ce qui est similaire au concept de bibliothèques de fonctions map-reduce dans de nombreux langages de programmation.

Type refine

Cette méthode génère un résumé de texte de manière récapitulative. Elle envoie d'abord le contenu du premier document au modèle LLM pour un résumé, puis envoie le contenu du résumé du premier document + le contenu du deuxième document au modèle LLM pour un résumé, et ainsi de suite, pour obtenir un résumé final pour un long texte.

Type map_rerank

Il est utilisé dans les tâches de question-réponse. Il sélectionne les fragments de document les plus pertinents par rapport à la question, puis les envoie au modèle LLM pour répondre à la question.

Exemple de tâche `stuff`

Voici un exemple de résumé d'un article en utilisant le type stuff, qui convient aux articles qui ne dépassent pas la limite de longueur de jeton du LLM :

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

chain.run(docs)

Mots d'invite personnalisés

Pour le type stuff, voici un exemple de mots d'invite personnalisés :

prompt_template = """Résumer le contenu suivant:

{text}

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

Exemple de tâche `map_reduce`

La tâche map_reduce résume l'article, et bien sûr, cette méthode entraînera plusieurs appels de modèles d'IA.

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

chain.run(docs)

Mots personnalisés pour la tâche map_reduce

prompt_template = """Résumez le contenu suivant :

{text}

Résumé :"""
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)

Exemple de tâche `refine`

Il suffit de changer le paramètre chain_type en refine.

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

Modèle de mots personnalisés pour la tâche refine

Voici un exemple de mots personnalisés pour la tâche refine :

prompt_template = """Résumez le contenu suivant :

{text}

Résumé :"""

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

refine_template = (
    "Votre tâche est de générer un résumé textuel final\n"
    "Voici les informations de résumé existantes : {existing_answer}\n"
    "Améliorez le résumé existant en fonction des nouvelles informations de base\n"
    "Les informations de base sont les suivantes\n"
    "------------\n"
    "{text}\n"
    "------------\n"
    "En fonction des informations de base, améliorez le résumé existant\n"
    "Renvoyez les informations de résumé existantes si les informations de base ne sont pas utiles."
)
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)

Tâche de résumé de texte LangChain