Comment résumer des articles avec Streamlit et LangChain avec Mistral 7B sur CPU | de Nuno Bispo | Django déchaîné | novembre 2023

Pour construire votre application, seuls 2 ensembles de fichiers seront nécessaires, l’un contiendra la logique de récapitulation avec LangChain et Mistal 7B, l’autre fichier contiendra l’interface UI avec Streamlit.

Tout d’abord, nous commençons à installer les exigences nécessaires. En supposant que vous ayez créé un nouveau projet Python et configuré un environnement virtuel, exécutez la commande :

pip install streamlit langchain beautifulsoup4 transformers transformers newspaper3k

Voici à quoi sert chaque package :

• streamlit: Il s’agit d’une bibliothèque Python open source qui facilite la création et le partage de superbes applications Web personnalisées pour l’apprentissage automatique et la science des données.
• langchain: LangChain est un framework Python pour développer des applications alimentées par des modèles de langage, qui simplifie l’intégration de grands modèles de langage (LLM) dans diverses applications.
• beautifulsoup4: BeautifulSoup est une bibliothèque Python pour analyser les documents HTML et XML. Il est couramment utilisé pour le web scraping, qui est le processus d’extraction d’informations à partir de sites Web.
• ctransformers and transformers: Cette bibliothèque de Hugging Face fournit des architectures à usage général pour la compréhension du langage naturel (NLU) et la génération du langage naturel (NLG) avec des milliers de modèles pré-entraînés dans plus de 100 langages, dont Mistral 7B.
• newspaper3k: Ce package est utilisé pour extraire et analyser des articles de journaux. Il est utile à des fins de scraping Web, permettant une récupération facile des articles et une curation de contenu.

Pour le Mistral 7B, vous utiliserez une version du Mistral 7B de Le mecqui est optimisé pour fonctionner sur le CPU, d’où l’utilisation de ctransforemers et transformers.

Commençons par le fichier logique de résumé en créant un nouveau fichier appelé summarizer.py:

import os
import time
from langchain.chains import MapReduceDocumentsChain, LLMChain, ReduceDocumentsChain, StuffDocumentsChain
from langchain.document_loaders import NewsURLLoader
from langchain.llms import CTransformers
from langchain.prompts import PromptTemplate
from langchain.text_splitter import RecursiveCharacterTextSplitter
def summarize_article(article_url):
# Load article
loader = NewsURLLoader([article_url])
docs = loader.load()
# Load LLM
config = {'max_new_tokens': 4096, 'temperature': 0.7, 'context_length': 4096}
llm = CTransformers(model="TheBloke/Mistral-7B-Instruct-v0.1-GGUF",
model_file="mistral-7b-instruct-v0.1.Q4_K_M.gguf",
config=config,
threads=os.cpu_count())
# Map template and chain
map_template = """<s>[INST] The following is a part of an article:
{docs}
Based on this, please identify the main points. 
Answer:  [/INST] </s>"""
map_prompt = PromptTemplate.from_template(map_template)
map_chain = LLMChain(llm=llm, prompt=map_prompt)
# Reduce template and chain
reduce_template = """<s>[INST] The following is set of summaries from the article:
{doc_summaries}
Take these and distill it into a final, consolidated summary of the main points. 
Construct it as a well organized summary of the main points and should be between 3 and 5 paragraphs.
Answer:  [/INST] </s>"""
reduce_prompt = PromptTemplate.from_template(reduce_template)
reduce_chain = LLMChain(llm=llm, prompt=reduce_prompt)
# Takes a list of documents, combines them into a single string, and passes this to an LLMChain
combine_documents_chain = StuffDocumentsChain(
llm_chain=reduce_chain, document_variable_name="doc_summaries"
)
# Combines and iteratively reduces the mapped documents
reduce_documents_chain = ReduceDocumentsChain(
# This is final chain that is called.
combine_documents_chain=combine_documents_chain,
# If documents exceed context for `StuffDocumentsChain`
collapse_documents_chain=combine_documents_chain,
# The maximum number of tokens to group documents into.
token_max=4000,
)
# Combining documents by mapping a chain over them, then combining results
map_reduce_chain = MapReduceDocumentsChain(
# Map chain
llm_chain=map_chain,
# Reduce chain
reduce_documents_chain=reduce_documents_chain,
# The variable name in the llm_chain to put the documents in
document_variable_name="docs",
# Return the results of the map steps in the output
return_intermediate_steps=True,
)
# Split documents into chunks
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=4000, chunk_overlap=0
)
split_docs = text_splitter.split_documents(docs)
# Run the chain
start_time = time.time()
result = map_reduce_chain.__call__(split_docs, return_only_outputs=True)
time_taken = time.time() - start_time
return result['output_text'], time_taken

Ce code définit une fonction summarize_article cela prend un article_url comme entrée et utilise le framework LangChain pour générer un résumé de l’article.

Voici une description étape par étape du processus :

1. Chargez l’article : Le NewsURLLoader est instancié avec le article_url (sous forme de liste), et il charge le(s) document(s) à partir du Web.
2. Configurez et chargez le modèle de langage : Il met en place une configuration pour le LLM, en spécifiant des paramètres tels que max_new_tokens, temperatureet context_length. Ensuite, il charge le CTransformers modèle de langage avec le modèle et la configuration spécifiés, définissant le nombre de threads sur le nombre de CPU du système pour le traitement parallèle.
3. Phase de cartographie avec modèle et chaîne : Il définit un map_template demander au LLM d’identifier les points principaux des parties de l’article. Ce modèle est transformé en un PromptTemplateet puis un LLMChain est configuré à l’aide du LLM et du modèle d’invite.
4. Réduire la phase avec un modèle et une chaîne : De même, un reduce_template est défini pour demander au LLM de distiller l’ensemble des résumés en un résumé final consolidé. UN PromptTemplate est créé à partir de ce modèle, et un nouveau LLMChain est mis en place pour la phase de réduction.
5. Combiner la chaîne de documents : Le StuffDocumentsChain est utilisé pour prendre une liste de résumés de documents et combinergroupe en une seule chaîne pour la phase finale de réduction.
6. Réduisez la chaîne de documents : Le ReduceDocumentsChain est configuré pour réduire de manière itérative les documents cartographiés en un résumé unique et concis. Il utilise combine_documents_chain pour ce processus et spécifie un token_max pour les documents de groupe.
7. Chaîne de réduction de carte : Le MapReduceDocumentsChain est configuré avec la chaîne de cartes et la chaîne de réduction pour traiter les documents. Il trace une chaîne sur les documents, puis combine les résultats.
8. Divisez les documents : Le code utilise un RecursiveCharacterTextSplitter pour diviser les documents en morceaux d’une taille spécifiée sans chevauchement.
9. Exécutez la chaîne : Il exécute ensuite la chaîne de réduction de mappage sur les documents fractionnés et imprime le temps nécessaire à l’opération.
10. Renvoie le résultat : La fonction renvoie enfin le résumé consolidé produit par la chaîne de réduction et le temps d’exécution.

Cette fonction décompose essentiellement la tâche de résumé en parties plus petites à l’aide du paradigme de réduction de carte, traite chaque partie avec le LLM, puis combine les résultats dans un résumé final.

Cette implémentation peut gérer des documents volumineux en les divisant en morceaux plus petits et en les traitant en parallèle, ce qui est bénéfique à la fois pour les performances et pour la gestion de la mémoire.

Concentrons-nous maintenant sur la création de l’interface utilisateur de votre application avec Streamlit en créant un nouveau fichier appelé main.py. Ce sera le fichier principal et le fichier que vous exécuterez pour exécuter l’application :

import streamlit as st
from summarizer import summarize_article
# Set page title
st.set_page_config(page_title="Article Summarizer", page_icon="
", layout="wide")
# Set title
st.title("Article Summarizer", anchor=False)
st.header("Summarize Articles with AI", anchor=False)
# Input URL
st.divider()
url = st.text_input("Enter Article URL", value="")
# Download audio
st.divider()
if url:
with st.status("Processing...", state="running", expanded=True) as status:
st.write("Summarizing Article...")
summary, time_taken = summarize_article(url)
status.update(label=f"Finished - Time Taken: {time_taken} seconds", state="complete")
# Show Summary
st.subheader("Summary:", anchor=False)
st.write(summary)

Voici un aperçu de ce que fait chaque partie du code :

1. Configuration de l’application simplifiée :

• st.set_page_config définit la configuration de la page Streamlit, en spécifiant le titre de la page (“Article Summarizer”), une icône emoji (“”) pour l’onglet du navigateur, et définit la mise en page sur “large”.

2. Titre et en-tête de l’application :

• st.title et st.header sont utilisés pour définir le titre et l’en-tête de l’application Web, qui sont respectivement “Article Summarizer” et “Summarize Articles with AI”.

3. Saisie de l’utilisateur pour l’URL de l’article :

• st.divider() ajoute un séparateur visuel dans l’interface utilisateur.
• st.text_input crée un champ de saisie de texte dans lequel les utilisateurs peuvent saisir l’URL de l’article qu’ils souhaitent résumer. Le champ est initialisé avec une valeur par défaut vide.

4. Traitement et synthèse :

• Si une URL est fournie, l’application affiche un message d’état « Traitement… » en utilisant st.status pour informer l’utilisateur que l’article est en cours de traitement.
• À l’intérieur de with bloque, il écrit le message “Article de synthèse…” dans l’application.
• L’URL fournie est ensuite transmise au summarize_article fonction, qui renvoie un résumé et le temps nécessaire au traitement de l’article.
• Une fois le résumé terminé, le message d’état est mis à jour sur « Terminé » avec le temps nécessaire pour générer le résumé.

5. Affichage du résumé :

• Après le traitement, un sous-en-tête « Résumé : » est ajouté à l’interface utilisateur.
• Le résumé renvoyé par le summarize_article La fonction est ensuite écrite sur la page afin que l’utilisateur puisse la lire.

L’application est simple, conviviale, interactive et fournit des commentaires en temps réel aux utilisateurs pendant le processus de synthèse.

to medium.com

---

Abonnez-vous à notre page Facebook: https://www.facebook.com/mycamer.net
Pour recevoir l’actualité sur vos téléphones à partir de l’application Telegram cliquez ici: https://t.me/+KMdLTc0qS6ZkMGI0
Nous ecrire par Whatsapp : Whatsapp +44 7476844931

---