La génération de résumé est une tâche de traitement du langage naturel qui consiste à créer un résumé concis et cohérent d’un texte plus long. Il existe différentes façons d’aborder cette tâche, allant de simples méthodes basées sur des règles à des modèles d’apprentissage automatique plus complexes. Dans cet article de blog, nous examinerons trois approches différentes pour générer des résumés : utiliser un modèle de langage pré-formé, utiliser un TfidfVectorizer et utiliser la distance cosinus de nltk.
La première approche consiste à utiliser un TfidfVectorizer pour générer un résumé. Cette approche consiste à créer une représentation vectorielle de chaque phrase du texte, puis à classer les phrases en fonction de leur pertinence. Pour implémenter cette approche, nous devons d’abord importer les bibliothèques requises et créer une fonction de résumé qui prend un morceau de texte et renvoie le résumé. La fonction commence par marquer le texte à l’aide de spacy, puis crée un objet TfidfVectorizer. Le TfidfVectorizer est ensuite ajusté sur la liste des phrases et utilisé pour transformer les phrases en vecteurs. Les vecteurs sont ensuite additionnés et les N premières phrases sont sélectionnées comme résumé, où N est le nombre de phrases que nous voulons dans le résumé.
La deuxième approche consiste à utiliser la distance cosinus de nltk pour générer un résumé. Cette approche consiste à mesurer la similitude entre les phrases et à sélectionner les phrases les plus similaires comme résumé. Pour implémenter cette approche, nous devons d’abord importer les bibliothèques requises et créer une fonction generate_summary qui prend un nom de fichier et renvoie le résumé. La fonction commence par lire le fichier et marquer les phrases à l’aide des mots vides de nltk. Ensuite, une matrice de similarité est créée en comparant chaque phrase à toutes les autres phrases du texte. La matrice est ensuite convertie en graphique à l’aide de networkx et l’algorithme PageRank est utilisé pour classer les phrases en fonction de leur importance. Les N premières phrases sont ensuite sélectionnées comme résumé.
La troisième approche consiste à utiliser un modèle de langage pré-entraîné, tel que T5, pour générer un résumé. Le modèle T5 a été formé sur un grand ensemble de données de texte et est capable de générer des résumés de type humain en prédisant le mot suivant dans une séquence. Pour utiliser cette approche, nous devons d’abord installer les bibliothèques requises et charger les données. Nous pouvons ensuite créer un NewsSummaryDataset et un NewsSummaryDataModule pour gérer le traitement et le chargement des données. Ensuite, nous pouvons définir notre modèle en créant un modèle T5ForConditionalGeneration et en spécifiant les hyperparamètres. Enfin, nous pouvons former le modèle en définissant un optimiseur AdamW et un rappel ModelCheckpoint pour enregistrer les poids du modèle à chaque époque.
BASE DE DONNÉES
Dans ce projet, nous n’avons utilisé qu’un seul ensemble de données et l’avons utilisé dans la formation du titre ainsi que du modèle de résumé 3
SOMMAIRE DES NOUVELLES
Génération de courtes descriptions d’articles de presse.
www.kaggle.com
DES MODÈLES
> MODÈLE TÊTE
le code du train miniature est présent dans le lien donné :
Collaboration Google
Éditer la description
colab.research.google.com
le code commence par importer les bibliothèques nécessaires et lire les données à partir d’un fichier CSV à l’aide de pandas. Les données consistent en des titres et du texte pour chaque article de presse. Les données sont ensuite prétraitées pour avoir le format correct pour la formation du modèle T5, qui attend une trame de données avec les colonnes « source_text » et « target_text » . Le texte source est le texte à résumer et le texte cible est le résumé.
Les données sont ensuite divisées en un ensemble d’apprentissage et un ensemble de test à l’aide de la fonction train_test_split de sci-kit-learn. La classe SimpleT5 est importée de la bibliothèque simplet5 et un modèle T5 est créé à l’aide de la méthode from_pretrained . Le modèle est ensuite entraîné sur l’ensemble d’entraînement à l’aide de la méthode d’entraînement. Le paramètre eval_df spécifie l’ensemble de test à utiliser pour l’évaluation pendant la formation. Les paramètres source_max_token_len et target_max_token_len spécifient respectivement les longueurs maximales du texte source et du texte cible. Le paramètre batch_size spécifie le nombre d’échantillons par mise à jour du gradient et le max_epochsLe paramètre spécifie le nombre maximal d’époques pour lesquelles s’entraîner. Le paramètre use_gpu spécifie s’il faut utiliser le GPU pour la formation.
> SOMMAIRE 3 MODÈLE
le code du train miniature est présent dans le lien donné :
Collaboration Google
Éditer la description
colab.research.google.com
Dans ce bloc de code, nous installons plusieurs bibliothèques nécessaires à notre tâche de synthèse de texte à l’aide du modèle T5. Ces bibliothèques incluent transformers , pytorch-lightning , torchtext et torchvision .
Nous importons ensuite ces bibliothèques ainsi que certaines bibliothèques supplémentaires telles que pandas , numpy et pyplot . Nous avons également défini certains paramètres de visualisation à l’aide de seaborn et matplotlib .
Ensuite, nous lisons un fichier CSV contenant des données textuelles et créons une base de données pandas avec les colonnes de texte et de résumé. Nous avons ensuite divisé les données en ensembles d’entraînement et de test à l’aide de train_test_split .
Nous définissons une classe NewsSummaryDataset qui prend en charge une trame de données et un objet T5Tokenizer, ainsi que des paramètres facultatifs pour les longueurs de jeton maximales. Cette classe nous permet d’accéder aux données de la trame de données en tant qu’objet de jeu de données, ce qui sera utile pour la formation et l’évaluation de notre modèle.
Nous définissons également une classe NewsSummaryDataModule qui hérite de la classe LightningDataModule de pytorch_lightning . Cette classe est chargée de créer des chargeurs de données pour nos ensembles de données d’entraînement et de test, et de spécifier certains hyperparamètres facultatifs tels que la taille du lot et les longueurs maximales des jetons de texte et de résumé.
Enfin, nous définissons une classe NewsSummaryModel qui hérite de la classe LightningModule de pytorch_lightning . Cette classe contient la logique pour former et évaluer notre modèle, ainsi que pour générer des résumés à partir du texte d’entrée. Il contient plusieurs méthodes clés telles que configure_optimizers , training_step , validation_step et test_step .
Une fois ces classes et fonctions définies, nous pouvons maintenant utiliser le NewsSummaryModel pour former et évaluer un modèle de résumé de texte à l’aide du modèle T5.
RÉSUMÉ EXTRACTIF
> SOMMAIRE 1
de sklearn.feature_extraction.text import TfidfVectorizer de spacy.lang.en import anglais numpy as np nlp = English() nlp.add_pipe( 'sentencizer' ) def resumer ( text, tokenizer=nlp, max_sent_in_summary= 3 ): doc = nlp (text.replace( "\n" , "" )) sentences = [sent.text.strip() for sent in doc.sents] sentence_organizer = {k:v for v,k in enumerate (sentences)} vectorizer = TfidfVectorizer(min_df= 2 , max_features= None , strip_accents= 'unicode' , analyzer= 'word' , token_pattern= r'\w{1,}' , ngram_range=( 1 , 3 ), use_idf= 1 ,smooth_idf= 1 , sublinear_tf= 1 , stop_words ='anglais' ) vectorizer.fit(sentences) vectors = vectorizer.transform(sentences) scores = np.array(vectors. sum (axis= 1 )).ravel() N = max_sent_in_summary top_n_sentences = [sentences[ind] for ind in np.argsort(scores, axis= 0 )[::- 1 ][:N]] top_n = [(sentence,sentence_organizer[sentence]) for phrase in top_n_sentences] top_n = trié (top_n, key = lambda x: x[ 1 ]) order_scored_sentences = [element[ 0] for element in top_n] summary = " " .join(ordered_scored_sentences) return summary
la fonction TfidfVectorizer de la bibliothèque scikit-learn est importée et utilisée pour vectoriser une liste de phrases. Le TfidfVectorizer convertit une liste de phrases en une matrice de valeurs numériques représentant l’importance de chaque mot dans chaque phrase.
L’objet nlp du module anglais de la bibliothèque spaCy est également importé et utilisé pour ajouter un tube sentencizer à l’objet nlp. Le Sentencizer est utilisé pour diviser le texte en phrases individuelles.
La fonction de synthèse prend un morceau de texte et un tokenizer, qui dans ce cas est l’objet nlp avec le tube sentencizer ajouté. La fonction prend également un paramètre pour le nombre maximum de phrases qui doivent être incluses dans le résumé.
Le texte est d’abord passé à travers l’objet nlp pour le diviser en phrases individuelles, qui sont ensuite stockées dans la variable ‘ sentences ‘. Le dictionnaire sentence_organizer est ensuite créé, qui associe chaque phrase à son index correspondant dans la liste de phrases d’origine.
Le TfidfVectorizer est ensuite adapté à la liste des phrases et utilisé pour transformer les phrases en vecteurs. La somme de chaque vecteur est calculée et stockée dans la variable ‘ scores ‘. Les N premières phrases avec les scores les plus élevés sont ensuite sélectionnées et stockées dans la liste ‘top_n_sentences’ .
La liste ‘ top_n ‘ est ensuite créée, qui est une liste de tuples contenant chacune des N premières phrases et son index correspondant dans la liste de phrases d’origine. La liste ‘ top_n ‘ est ensuite triée en fonction des indices des phrases. Le résumé final est créé en joignant la liste triée des phrases et renvoyé en sortie.
> SOMMAIRE 2
import nltk #Natural Language ToolKit nltk.download( 'stopwords' ) from nltk.corpus import stopwords from nltk.cluster.util import cosine_distance import numpy as np import networkx as nx def read_article ( file_name ): with open (file_name) as f: a = " " .join(line.strip() for line in f) with open (file_name,"r+" ) as f: f.truncate( 0 ) f.write(a) file = open (file_name, "r" ) filedata = file.readlines() #print(filedata) article = filedata[ 0 ].split( ". " ) sentances=[] pour la phrase dans l' article : sentances.append(sentance.replace( "[^a-zA-Z]" , "" ).split( " " )) #sentances.pop() renvoie les phrases def sentance_similarity ( envoyé1, envoyé2,mots vides=None ): si les mots vides sont None :stopwords =[] sent1 = [w.lower() for w in sent1] sent2 = [w.lower() for w in sent2] all_words = list ( set (sent1+sent2)) vector1 = [ 0 ] * len (all_words) vector2= [ 0 ] * len (all_words) for w in sent1 : if w in stopwords : continue vector1[all_words.index(w)] += 1 for w in sent2: if w in stopwords: continue vector2[all_words.index(w)] += 1 return 1 -cosine_distance(vector1,vector2) def gen_sim_matrix ( phrases,stop_words ): similarity_matrix=np.zeros(( len (phrases), len (phrases))) pour idx1 dans la plage ( len (phrases)): pour idx2 dans la plage ( len (phrases)):if idx1 == idx2: continue similarity_matrix[idx1][idx2]=sentance_similarity(sentances[idx1],sentances[idx2],stop_words) return similarity_matrix def generate_summary ( file_name,top_n= 5 ): stop_words=stopwords.words( 'anglais' ) resume_text =[] phrases = read_article(nom_fichier) matrix=gen_sim_matrix(phrases,stop_words) graph=nx.from_numpy_array(matrice) scores = nx.pagerank(graph) ranking_sentance= trié (((scores[i],s) pour i ,s dans énumérer (phrases)),reverse=True ) pour i dans la plage (top_n) : resume_text.append ( " " .join(ranked_sentance[i][ 1 ])) text = ". " .join(summarize_text)
Ici, nous utilisons l’algorithme TextRank pour extraire des résumés d’un morceau de texte. L’algorithme TextRank est une méthode basée sur des graphiques pour les tâches de traitement du langage naturel telles que la synthèse, l’extraction de mots clés et la traduction automatique.
Le code commence par importer les bibliothèques nécessaires, y compris le Natural Language Toolkit (nltk) et la bibliothèque networkx pour travailler avec des graphiques en Python. Le corpus de mots vides de nltk est également téléchargé et importé, qui est une liste de mots anglais courants qui sont souvent supprimés des données textuelles car ils n’apportent pas beaucoup de sens.
La fonction read_article lit un fichier texte et le divise en phrases individuelles. La fonction sentance_similarity calcule la similarité entre deux phrases en fonction de la présence de mots communs, à l’exclusion des mots vides. La fonction gen_sim_matrix génère une matrice de scores de similarité pour toutes les paires de phrases du texte.
La fonction generate_summary est la fonction principale pour générer un résumé du texte. Il appelle d’abord la fonction gen_sim_matrix pour créer une matrice de scores de similarité, puis convertit cette matrice en un graphique à l’aide de la bibliothèque networkx . L’algorithme PageRank est ensuite appliqué au graphique pour calculer un score pour chaque phrase. Les N phrases les mieux classées sont ensuite sélectionnées et renvoyées sous forme de résumé.
Ce code utilise un modèle de résumé pré-formé pour générer un résumé d’un morceau de texte donné. La classe SummaryModel est importée du module summary_model .model, ainsi que de la fonction tokenizer. Le modèle_formé est ensuite chargé à partir d’un fichier de point de contrôle à l’aide de la méthode load_from_checkpoint et gelé pour empêcher une formation ultérieure.
La fonction de résumé prend un morceau de texte et l’encode à l’aide de la fonction tokenizer. Le texte encodé est ensuite transmis à la méthode de génération du modèle, qui génère un résumé du texte. Le résumé généré est renvoyé en sortie.
La méthode de génération a plusieurs paramètres qui peuvent être ajustés pour contrôler le comportement de la génération de résumé. Le paramètre max_length spécifie la longueur maximale du résumé généré, le paramètre num_beams contrôle le nombre de faisceaux utilisés dans l’algorithme de recherche de faisceau, et les paramètres repeat_penalty et length_penalty contrôlent le compromis entre répétition et longueur dans le résumé généré.
> À LA UNE
from simplet5 import SimpleT5 def generate_headline ( text ): model = SimpleT5() model.load_model( "t5" , "models\\headline_model" , use_gpu= False ) headline = model.predict(text)[ 0 ] return headline
modèle T5 pré-formé pour générer un titre pour un morceau de texte donné. La classe SimpleT5 est importée de la bibliothèque simplet5, qui fournit une interface simple pour utiliser le modèle T5.
La fonction generate_headline prend un morceau de texte et crée un objet SimpleT5. Le modèle est ensuite chargé à partir d’un fichier de point de contrôle à l’aide de la méthode load_model et le GPU est désactivé pour la prédiction. Le texte est ensuite transmis à la méthode de prédiction du modèle, qui génère un titre pour le texte. Le titre généré est renvoyé en sortie.
Le modèle T5 est un modèle de langage basé sur un transformateur qui a obtenu des résultats de pointe sur un large éventail de tâches de traitement du langage naturel, y compris le résumé et la génération de titres.
PDF VERS TEXTE
C’est l’une des fonctionnalités où l’utilisateur peut également télécharger son pdf pour résumer
La première étape consiste à installer la bibliothèque PyPDF2 à l’aide de pip. Vous pouvez le faire en exécutant la commande suivante :
pip installer pypdf2
Une fois la bibliothèque installée, nous pouvons commencer à l’utiliser pour extraire du texte d’un fichier PDF. Voici une fonction simple qui prend un chemin de fichier en entrée et renvoie le texte du fichier PDF sous forme de chaîne :
def pdf_to_text ( file ): pdffile = open ( file , 'rb ' ) pdfReader = PyPDF2 . PDFFileReader ( pdffile ) num = pdfReader . numPages for in in range ( 0 , num ): pageobj = pdfReader . getPage ( i ) resulttext = pageobj .extractText() newfile = open ( r"content.txt" , "w" ) newfile.writelines(resulttext) demo= open ( "content.txt" , "r" ) str1=demo.read() returnchaîne1
Examinons de plus près ce qui se passe dans le code ci-dessus. Tout d’abord, nous ouvrons le fichier PDF en mode lecture seule et créons un objet lecteur PDF. Ensuite, nous obtenons le nombre de pages dans le fichier PDF et parcourons chaque page pour extraire le texte. Nous ouvrons un nouveau fichier texte et y écrivons le texte. Enfin, nous ouvrons le fichier texte, lisons le contenu et le renvoyons sous forme de chaîne.
Pour utiliser la fonction ci-dessus, tout ce que vous avez à faire est de passer le chemin du fichier PDF en argument. La fonction renverra le texte du fichier PDF sous forme de chaîne. Vous pouvez ensuite utiliser le texte pour un traitement ultérieur ou l’enregistrer dans un fichier texte.
En conclusion, PyPDF2 est une bibliothèque puissante qui nous permet d’extraire facilement du texte d’un fichier PDF et de l’enregistrer sous forme de fichier texte ou de chaîne. C’est un outil utile pour tous ceux qui travaillent avec des fichiers PDF et qui ont besoin d’extraire le texte pour un traitement ultérieur.
PRINCIPAL
import streamlit as st from io import StringIO from pdf_txt import pdf_to_text from headline import generate_headline from summaryr1 import resumer from summaryr2 import generate_summary from summaryr3 import resume from pathlib import Path import os st.markdown( "<h1 style='text-align: center; '>RÉSUMÉ DE TEXTE v2.0</h1>" , unsafe_allow_html=Vrai ) file = st.file_uploader( "Veuillez choisir un fichier" , tapez =[ 'txt' , 'pdf' ]) st.markdown( "<h5 style='text-align: center;'>OU</h5> " , unsafe_allow_html= True ) text = st.text_area( "Texte d'entrée pour le résumé (plus de 200 mots)" , height= 200 ) col1, col2, col3 = st.columns( 3 ) if col1.button( 'SUMMARIZE' ) : #try : si le fichier n'est pas Aucun :si bool (texte)== Vrai : st.error( "ERREUR : VOUS NE POUVEZ PAS ENTRER LES DEUX" ) st.stop() else : if file.name[- 3 :] == "pdf" : path=Path( "uploaded_pdfs/" + file.name) path.write_bytes(file.getvalue()) text = pdf_to_text( "uploaded_pdfs/" + file.name) else : stringio = StringIO(file.getvalue().decode( "utf-8" )) text=stringio.read( ) fichier texte = ouvrir ( "contenu.txt" ,"w") textfile.write(text) textfile.close() headline=generate_headline(text) summary1=summarizer(text) summary2=generate_summary( "content.txt" ) summary3=summarize(text) st.write( "" ) st.subheader (titre) st.markdown( "<h4> > Résumé 1 : </h4>" , unsafe_allow_html= True ) st.write(summary1) st.markdown( "<h4> > Résumé 2 : </h4>" , unsafe_allow_html = Vrai ) st.écrire (résumé2) st.markdown ("<h4> > Résumé 3 : </h4>" , unsafe_allow_html= Vrai ) st.write(summary3)
Le code ci-dessus est destiné à une application Streamlit qui permet aux utilisateurs de saisir du texte ou un fichier PDF et de générer des résumés de l’entrée.
La première ligne importe la bibliothèque Streamlit. Les quatre lignes suivantes importent diverses fonctions d’autres modules : pdf_to_textpour extraire du texte d’un fichier PDF, generate_headlinepour générer un titre pour le texte d’entrée, summarizer, generate_summaryet summarizepour générer des résumés du texte d’entrée. Les bibliothèques pathlibet ossont également importées.
L’application commence par afficher un titre et un widget de téléchargement de fichiers. L’utilisateur a la possibilité de saisir un fichier texte ou un fichier PDF, ou de saisir du texte directement dans un widget de zone de texte. L’utilisateur peut ensuite cliquer sur le bouton « RÉSUMÉ » pour générer des résumés de l’entrée.
Si l’utilisateur saisit un fichier, le code vérifie s’il s’agit ou non d’un fichier PDF. S’il s’agit d’un PDF, le code utilise la pdf_to_textfonction pour extraire le texte du fichier et le stocker dans une variable appelée text. S’il ne s’agit pas d’un PDF, le code lit le texte du fichier et le stocke au format text. La textvariable est ensuite écrite dans un fichier nommé « content.txt ».
Le code appelle ensuite les fonctions generate_headline, summarizer, generate_summaryet summarizepour générer trois résumés du texte saisi. Le titre et les résumés sont ensuite affichés à l’utilisateur.
CONCLUSION
En conclusion, diverses approches peuvent être adoptées pour générer des résumés de texte. Chaque approche a ses propres forces et faiblesses et la meilleure approche dépendra.
