Article Summarizer Using AI

Article-Summizer-Using-Aai

Une application Web basée sur l'IA qui fournit des résumés concis d'articles utilisant des techniques avancées de traitement du langage naturel (NLP).

Table des matières

• Introduction
• Exploration des données
• Sélection du modèle
• Modèle de réglage fin
• Résumé extractif
• Développement d'applications Web
• Installation
• Usage

Introduction

Article-Summizer-Using-AI est une application Web conçue pour résumer de longs articles à l'aide de NLP. L'application permet aux utilisateurs de télécharger leurs propres articles ou d'utiliser des exemples de données pour générer des résumés dans divers styles, en utilisant un modèle d'IA génératif.

Exploration des données

Ensemble de données

L'ensemble de données utilisé pour la formation et l'évaluation est l'ensemble de données PubMed Résumé. Il comprend des articles de PubMed avec des résumés correspondants utilisés comme résumés.

1. Chargement de l'ensemble de données :

    from datasets import load_dataset
   
   pubmed_data = load_dataset ( "ccdv/pubmed-summarization" , split = 'train[:1000]' )

2. Nettoyage initial des données :

   • Supprimez les lignes avec des valeurs manquantes pour assurer la qualité des données.

    pubmed_data = pubmed_data . filter ( lambda x : x [ 'article' ] is not None and x [ 'abstract' ] is not None )

3. Analyse des données exploratoires :

   • Examinez la distribution des longueurs de l'article et des longueurs de résumé.
   • Identifiez les sujets et la terminologie courants dans l'ensemble de données.

    print ( pubmed_data [ 0 ])  # View the first data entry 

Sélection du modèle

Prétraitement

1. Tokenisation du texte :

   • Diviser le texte en phrases et mots pour une analyse détaillée.

    from nltk . tokenize import sent_tokenize , word_tokenize
   
   sentences = sent_tokenize ( article_text )
   words = word_tokenize ( sentence )

2. Retrait des mots d'arrêt :

   • Supprimez les mots anglais communs qui ne contribuent pas au résumé.

    from nltk . corpus import stopwords
   
   stop_words = set ( stopwords . words ( 'english' ))
   words = [ word for word in words if word . lower () not in stop_words ]

3. Lemmatisation :

   • Convertissez les mots en leurs formes de base.

    from nltk . stem import WordNetLemmatizer
   
   lemmatizer = WordNetLemmatizer ()
   words = [ lemmatizer . lemmatize ( word . lower ()) for word in words ]

Modèle génératif

1. Configuration de l'API :

   • Utilisez la bibliothèque google.generativeai pour la génération de modèles.

    import google . generativeai as genai
   import os
   
   api_key = os . environ . get ( 'your_api_key' )
   genai . configure ( api_key = api_key )

2. Initialisation du modèle :

   • Configurez le modèle générateur d'IA.

    model = genai . GenerativeModel ()

Modèle de réglage fin

Entraînement

• Affinez le modèle avec l'ensemble de données PubMed pour améliorer la qualité du résumé.

   # Example pseudo-code for fine-tuning
  model . train ( dataset = pubmed_data , epochs = 10 , learning_rate = 0.001 )

Résumé extractif

Approche

Pour une résumé extractif, l'application utilise des techniques de PNL traditionnelles pour identifier les phrases clés de l'article sans s'appuyer sur un modèle génératif.

1. Script de résumé extractif :

   Renommez le fournit extractive_summary.py à app.py et le déplacer vers la racine du projet:

   mv /mnt/data/extractive_summary.py app.py

2. Logique de base :

   • Le script de résumé extractif utilise des méthodes statistiques et heuristiques pour identifier les phrases les plus importantes du texte.

    # Example of extractive summarization
   def extractive_summary ( text ):
       # Tokenize the text and rank sentences
       sentences = sent_tokenize ( text )
       # Rank and select key sentences (pseudo-code)
       summary = ' ' . join ( sentences [: 3 ])  # Example: Select first 3 sentences
       return summary

3. Intégration :

   • Intégrez la logique de résumé extractive avec l'application Flask pour permettre aux utilisateurs de choisir entre les résumés génératifs et extractifs.

    @ app . route ( '/summarize' , methods = [ 'POST' ])
   def summarize ():
       if 'file' in request . files and request . files [ 'file' ]. filename != '' :
           file = request . files [ 'file' ]
           article_text = file . read (). decode ( "utf-8" )
       else :
           sample_index = int ( request . form [ 'sample' ])
           article_text = pubmed_data [ sample_index ][ 'article' ]
   
       style = request . form . get ( 'style' , 'brief' )
       summary_method = request . form . get ( 'method' , 'generative' )
       
       if summary_method == 'generative' :
           summary_text = preprocess_and_summarize ( article_text , style )
       else :
           summary_text = extractive_summary ( article_text )
   
       return render_template ( 'result.html' , original = article_text , summary = summary_text )

Évaluation

• Évaluez les performances du modèle à l'aide de mesures telles que Rouge ou Bleu.

   from nltk . translate . bleu_score import sentence_bleu
  
  reference = [ reference_summary . split ()]
  candidate = generated_summary . split ()
  score = sentence_bleu ( reference , candidate )
  print ( f'BLEU Score: { score } ' )

Développement d'applications Web

Backend

• Configuration du flacon :

  • Initialisez l'application FLASK et configurez le gestionnaire de connexion.

   from flask import Flask
  from flask_login import LoginManager
  
  app = Flask ( __name__ )
  app . secret_key = 'your_secret_key'
  login_manager = LoginManager ( app )

• Routes et authentification :

  • Implémentez les routes pour la connexion, l'enregistrement, le résumé et la déconnexion.

   @ app . route ( '/login' , methods = [ 'GET' , 'POST' ])
  def login ():
      # login logic here
      return render_template ( 'login.html' )

L'extrémité avant

• Modèles :

  • Créez des modèles HTML pour l'interface utilisateur.

   <!-- templates/index.html -->
  < form action =" {{ url_for('summarize') }} " method =" post " enctype =" multipart/form-data " >
      < input type =" file " name =" file " >
      < button type =" submit " > Summarize </ button >
  </ form >

• Expérience utilisateur :

  • Assurez-vous une interface conviviale avec des instructions et des commentaires clairs.

Installation

Condition préalable

• Python 3.7+
• Ballon
• NLTK
• Bibliothèque généative AI (par exemple, Google.Generativeai)
• Une clé API pour Generative AI

Mesures

1. Clone le référentiel :

   git clone https://github.com/yourusername/Article-Summarizer-Using-AI.git

2. Accédez au répertoire du projet :

    cd Article-Summarizer-Using-AI

3. Créer un environnement virtuel :

   python -m venv venv
   source venv/bin/activate  # On Windows use `venvScriptsactivate`

4. Installez les dépendances :

   pip install -r requirements.txt

5. Définir les variables d'environnement :

   • Créez un fichier .env avec votre clé API.

    your_api_key=<YOUR_GENERATIVE_AI_API_KEY>
   

6. Télécharger les données NLTK :

   Le script gère le téléchargement des données NLTK nécessaires.

Usage

1. Exécutez l'application :

   flask run --port=5001

2. Accéder à l'application :

   • Visitez http://127.0.0.1:5001 dans votre navigateur.

3. Connexion / enregistrement :

   • Enregistrez un nouveau compte ou connectez-vous avec les informations d'identification existantes.

4. Résumez les articles :

   • Téléchargez un fichier texte ou choisissez un échantillon pour résumer.

5. Afficher le résumé :

   • Le texte résumé s'affiche sur la page de résultats.

Merci d'utiliser l'article-Summizer-Using-ai ! Nous espérons que vous le trouverez utile pour vos besoins de résumé.